Merge pull request #95262 from NixOS/haskell-updates

Update Haskell package set to LTS 16.9 (plus other fixes)

pkgs/development/compilers/ghc/8.10.1.nix

···
   name = "${targetPrefix}ghc-${version}";
 
   src = fetchurl {
-    url = "https://downloads.haskell.org/ghc/8.10.1/ghc-${version}-src.tar.xz";
+    url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
     sha256 = "1xgdl6ig5jzli3bg054vfryfkg0y6wggf68g66c32sr67bw0ffsf";
   };
 

pkgs/development/compilers/ghc/8.10.2.nix

···
+{ 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 ? !(stdenv.lib.any (stdenv.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 ? stdenv.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 = stdenv.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"}
+  '' + stdenv.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
+  '' + stdenv.lib.optionalString (!enableProfiledLibs) ''
+    GhcLibWays = "v dyn"
+  '' + stdenv.lib.optionalString enableRelocatedStaticLibs ''
+    GhcLibHcOpts += -fPIC
+    GhcRtsHcOpts += -fPIC
+  '' + stdenv.lib.optionalString targetPlatform.useAndroidPrebuilt ''
+    EXTRA_CC_OPTS += -std=gnu99
+  '';
+
+  # Splicer will pull out correct variations
+  libDeps = platform: stdenv.lib.optional enableTerminfo ncurses
+    ++ [libffi]
+    ++ stdenv.lib.optional (!enableIntegerSimple) gmp
+    ++ stdenv.lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
+
+  toolsForTarget = [
+    pkgsBuildTarget.targetPackages.stdenv.cc
+  ] ++ stdenv.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" ];
+
+  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${stdenv.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
+  '' + stdenv.lib.optionalString (!stdenv.isDarwin) ''
+    export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"
+  '' + stdenv.lib.optionalString stdenv.isDarwin ''
+    export NIX_LDFLAGS+=" -no_dtrace_dof"
+  '' + stdenv.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
+  '' + stdenv.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" ]
+    ++ stdenv.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"
+  ] ++ stdenv.lib.optionals (libffi != null) [
+    "--with-system-libffi"
+    "--with-ffi-includes=${targetPackages.libffi.dev}/include"
+    "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
+  ] ++ stdenv.lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
+    "--with-gmp-includes=${targetPackages.gmp.dev}/include"
+    "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
+  ] ++ stdenv.lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
+    "--with-iconv-includes=${libiconv}/include"
+    "--with-iconv-libraries=${libiconv}/lib"
+  ] ++ stdenv.lib.optionals (targetPlatform != hostPlatform) [
+    "--enable-bootstrap-with-devel-snapshot"
+  ] ++ stdenv.lib.optionals useLdGold [
+    "CFLAGS=-fuse-ld=gold"
+    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
+    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
+  ] ++ stdenv.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 ]
+    ++ stdenv.lib.optional useLLVM llvmPackages.llvm;
+
+  depsTargetTarget = map stdenv.lib.getDev (libDeps targetPlatform);
+  depsTargetTargetPropagated = map (stdenv.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" ] ++ stdenv.lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
+
+  checkTarget = "test";
+
+  hardeningDisable = [ "format" ] ++ stdenv.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:${stdenv.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 stdenv.lib.maintainers; [ marcweber andres peti ];
+    inherit (ghc.meta) license platforms;
+  };
+
+} // stdenv.lib.optionalAttrs targetPlatform.useAndroidPrebuilt {
+  dontStrip = true;
+  dontPatchELF = true;
+  noAuditTmpdir = true;
+})

pkgs/development/compilers/ghc/8.8.2.nix

···
   name = "${targetPrefix}ghc-${version}";
 
   src = fetchurl {
-    url = "https://downloads.haskell.org/ghc/8.8.2/ghc-${version}-src.tar.xz";
+    url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
     sha256 = "02qa6wgjpxgakg7hv4zfdlrx9k7zxa5i02wnr6y9fsv8j16sbkh1";
   };
 

pkgs/development/compilers/ghc/head.nix

···
 , # 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
···
     HADDOCK_DOCS = NO
     BUILD_SPHINX_HTML = NO
     BUILD_SPHINX_PDF = NO
+  '' + stdenv.lib.optionalString (!enableProfiledLibs) ''
+    GhcLibWays = "v dyn"
   '' + stdenv.lib.optionalString enableRelocatedStaticLibs ''
     GhcLibHcOpts += -fPIC
     GhcRtsHcOpts += -fPIC

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

···
       name = "git-annex-${super.git-annex.version}-src";
       url = "git://git-annex.branchable.com/";
       rev = "refs/tags/" + super.git-annex.version;
-      sha256 = "vwKcY7Yk+R0YkaXjJ7xKyQWGjySTUPox0xIaurbQZk0=";
+      sha256 = "1d24080xh7gl197i0y5bkn3j94hvh8zqyg9gfcnx2qdlxfca1knb";
     };
   }).override {
     dbus = if pkgs.stdenv.isLinux then self.dbus else null;
···
           '';
         })).override {
           # we are faster than stack here
-          hie-bios = dontCheck self.hie-bios_0_6_1;
+          hie-bios = dontCheck self.hie-bios_0_6_2;
           lsp-test = dontCheck self.lsp-test_0_11_0_4;
         });
 
···
       # use a fork of ghcide
       ghcide = self.hls-ghcide;
       # we are faster than stack here
-      hie-bios = dontCheck self.hie-bios_0_6_1;
+      hie-bios = dontCheck self.hie-bios_0_6_2;
       lsp-test = dontCheck self.lsp-test_0_11_0_4;
     };
 
   # https://github.com/kowainik/policeman/issues/57
   policeman = doJailbreak super.policeman;
 
-  # 2020-06-29: These three packages have bumped their dependencies for haskell-gi and haskell-gi-base beyond stack-lts.
-  # Choosing a jailbreak, because a version override would rebuild most of the glibverse and the packages still build with the older version.
-  gi-javascriptcore =
-    # Remove these jailbreaks, when assert fails.
-    assert (pkgs.lib.versionOlder super.haskell-gi-base.version "0.24");
-    doJailbreak super.gi-javascriptcore;
-  gi-soup = doJailbreak super.gi-soup;
-  gi-webkit2 = doJailbreak super.gi-webkit2;
+  # 2020-08-14: gi-pango from stackage is to old for the C libs it links against in nixpkgs.
+  # That's why we need to bump a ton of dependency versions to unbreak them.
+  gi-pango = assert super.gi-pango.version == "1.0.22"; self.gi-pango_1_0_23;
+  haskell-gi-base = assert super.haskell-gi-base.version == "0.23.0"; addBuildDepends (self.haskell-gi-base_0_24_2) [ pkgs.gobject-introspection ];
+  haskell-gi = assert super.haskell-gi.version == "0.23.1"; self.haskell-gi_0_24_4;
+  gi-cairo = assert super.gi-cairo.version == "1.0.23"; self.gi-cairo_1_0_24;
+  gi-glib = assert super.gi-glib.version == "2.0.23"; self.gi-glib_2_0_24;
+  gi-gobject = assert super.gi-gobject.version == "2.0.22"; self.gi-gobject_2_0_24;
+  gi-atk = assert super.gi-atk.version == "2.0.21"; self.gi-atk_2_0_22;
+  gi-gio = assert super.gi-gio.version == "2.0.26"; self.gi-gio_2_0_27;
+  gi-gdk = assert super.gi-gdk.version == "3.0.22"; self.gi-gdk_3_0_23;
+  gi-gtk = assert super.gi-gtk.version == "3.0.33"; self.gi-gtk_3_0_35;
+  gi-gdkpixbuf = assert super.gi-gdkpixbuf.version == "2.0.23"; self.gi-gdkpixbuf_2_0_24;
+
+  # 2020-08-14: Needs some manual patching to be compatible with haskell-gi-base 0.24
+  # Created upstream PR @ https://github.com/ghcjs/jsaddle/pull/119
+  jsaddle-webkit2gtk = appendPatch super.jsaddle-webkit2gtk (pkgs.fetchpatch {
+    url = "https://github.com/ghcjs/jsaddle/compare/9727365...09f44aa.patch";
+    sha256 = "1bkwgmc04544haycb69fqsd97lg24jc7hc1yrin2sgr4l7hz04pf";
+    stripLen = 2;
+    extraPrefix = "";
+  });
 
   # Missing -Iinclude parameter to doc-tests (pull has been accepted, so should be resolved when 0.5.3 released)
   # https://github.com/lehins/massiv/pull/104
···
       haskeline = self.haskeline_0_8_0_0;
     };
   };
+
+  # https://github.com/bos/statistics/issues/170
+  statistics = dontCheck super.statistics;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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
-  # LTS Haskell 16.8
+  # LTS Haskell 16.9
   - abstract-deque ==0.3
   - abstract-par ==0.3.3
   - AC-Angle ==1.0
···
   - aeson-yak ==0.1.1.3
   - aeson-yaml ==1.0.6.0
   - al ==0.1.4.2
-  - alarmclock ==0.7.0.4
+  - alarmclock ==0.7.0.5
   - alerts ==0.1.2.0
   - alex ==3.2.5
   - alg ==0.2.13.1
···
   - asn1-parse ==0.9.5
   - asn1-types ==0.3.4
   - assert-failure ==0.1.2.3
-  - assoc ==1.0.1
+  - assoc ==1.0.2
   - astro ==0.4.2.1
   - async ==2.2.2
   - async-extra ==0.2.0.0
···
   - avers ==0.0.17.1
   - avro ==0.5.2.0
   - aws-cloudfront-signed-cookies ==0.2.0.6
-  - bank-holidays-england ==0.2.0.4
+  - bank-holidays-england ==0.2.0.5
   - base16 ==0.2.1.0
   - base16-bytestring ==0.1.1.7
   - base16-lens ==0.1.2.0
···
   - control-monad-omega ==0.3.2
   - convertible ==1.1.1.0
   - cookie ==0.4.5
-  - core-data ==0.2.1.7
-  - core-program ==0.2.4.4
-  - core-text ==0.2.3.5
+  - core-data ==0.2.1.8
+  - core-program ==0.2.4.5
+  - core-text ==0.2.3.6
   - countable ==1.0
   - cpio-conduit ==0.7.0
   - cpphs ==1.20.9.1
···
   - editor-open ==0.6.0.0
   - egison ==4.0.3
   - egison-pattern-src ==0.2.1.0
-  - egison-pattern-src-th-mode ==0.2.1.0
+  - egison-pattern-src-th-mode ==0.2.1.1
   - either ==5.0.1.1
   - either-both ==0.1.1.1
   - either-unwrap ==1.1
···
   - feed ==1.3.0.1
   - FenwickTree ==0.1.2.1
   - fft ==0.1.8.6
-  - fgl ==5.7.0.2
+  - fgl ==5.7.0.3
   - filecache ==0.4.1
   - file-embed ==0.0.11.2
   - file-embed-lzma ==0
···
   - ghcid ==0.8.7
   - ghci-hexcalc ==0.1.1.0
   - ghcjs-codemirror ==0.0.0.2
-  - ghc-lib ==8.10.1.20200523
-  - ghc-lib-parser ==8.10.1.20200523
-  - ghc-lib-parser-ex ==8.10.0.15
+  - ghc-lib ==8.10.2.20200808
+  - ghc-lib-parser ==8.10.2.20200808
+  - ghc-lib-parser-ex ==8.10.0.16
   - ghc-parser ==0.2.2.0
   - ghc-paths ==0.1.0.12
   - ghc-prof ==1.4.1.7
···
   - gi-pango ==1.0.22
   - giphy-api ==0.7.0.0
   - githash ==0.1.4.0
-  - github-rest ==1.0.2
+  - github-rest ==1.0.3
   - github-types ==0.2.1
   - gitlab-haskell ==0.1.8
   - gitrev ==1.3.1
···
   - graph-core ==0.3.0.0
   - graphite ==0.10.0.1
   - graphs ==0.7.1
-  - graphviz ==2999.20.0.4
+  - graphviz ==2999.20.1.0
   - graph-wrapper ==0.2.6.0
   - gravatar ==0.8.0
   - greskell ==1.1.0.3
···
   - hedgehog-fakedata ==0.0.1.3
   - hedgehog-fn ==1.0
   - hedgehog-quickcheck ==0.1.1
-  - hedis ==0.12.13
+  - hedis ==0.12.14
   - here ==1.2.13
   - heredoc ==0.2.0.0
   - heterocephalus ==1.0.5.3
···
   - hsebaysdk ==0.4.1.0
   - hsemail ==2.2.0
   - hset ==2.2.0
-  - hs-functors ==0.1.6.0
+  - hs-functors ==0.1.7.1
   - hs-GeoIP ==0.3
   - hsini ==0.5.1.2
   - hsinstall ==2.6
···
   - hspec-expectations ==0.8.2
   - hspec-expectations-lifted ==0.10.0
   - hspec-expectations-pretty-diff ==0.7.2.5
-  - hspec-golden ==0.1.0.2
+  - hspec-golden ==0.1.0.3
   - hspec-golden-aeson ==0.7.0.0
   - hspec-hedgehog ==0.0.1.2
   - hspec-leancheck ==0.0.4
···
   - intro ==0.7.0.0
   - intset-imperative ==0.1.0.0
   - invariant ==0.5.3
-  - invertible ==0.2.0.6
-  - invertible-grammar ==0.1.2
+  - invertible ==0.2.0.7
+  - invertible-grammar ==0.1.3
   - io-machine ==0.2.0.0
   - io-manager ==0.1.0.2
   - io-memoize ==1.1.1.0
···
   - matplotlib ==0.7.5
   - matrices ==0.5.0
   - matrix ==0.3.6.1
-  - matrix-as-xyz ==0.1.1.3
+  - matrix-as-xyz ==0.1.2.2
   - matrix-market-attoparsec ==0.1.1.3
   - matrix-static ==0.3
   - maximal-cliques ==0.1.1
···
   - miso ==1.6.0.0
   - missing-foreign ==0.1.1
   - MissingH ==1.4.3.0
-  - mixed-types-num ==0.4.0.1
+  - mixed-types-num ==0.4.0.2
   - mixpanel-client ==0.2.1
   - mltool ==0.2.0.1
   - mmap ==0.5.9
···
   - nonce ==1.0.7
   - nondeterminism ==1.4
   - non-empty ==0.3.2
-  - nonempty-containers ==0.3.3.0
+  - nonempty-containers ==0.3.4.0
   - nonemptymap ==0.0.6.0
   - non-empty-sequence ==0.2.0.4
   - nonempty-vector ==0.2.0.2
···
   - OneTuple ==0.2.2.1
   - Only ==0.1
   - oo-prototypes ==0.1.0.0
-  - opaleye ==0.6.7004.2
+  - opaleye ==0.6.7005.0
   - OpenAL ==1.7.0.5
   - open-browser ==0.2.1.0
   - openexr-write ==0.1.0.2
···
   - pandoc-plot ==0.6.1.0
   - pandoc-pyplot ==2.3.0.1
   - pandoc-types ==1.20
-  - pantry ==0.4.0.1
+  - pantry ==0.4.0.2
   - papillon ==0.1.1.1
   - parallel ==3.2.2.0
   - parallel-io ==0.3.3
···
   - pg-transact ==0.3.1.1
   - phantom-state ==0.2.1.2
   - pid1 ==0.1.2.0
-  - pipes ==4.3.13
+  - pipes ==4.3.14
   - pipes-aeson ==0.4.1.8
   - pipes-attoparsec ==0.5.1.5
   - pipes-binary ==0.4.2
···
   - rhine ==0.6.0
   - rhine-gloss ==0.6.0.1
   - rigel-viz ==0.2.0.0
-  - rio ==0.1.17.0
+  - rio ==0.1.18.0
   - rio-orphans ==0.1.1.0
-  - rio-prettyprint ==0.1.0.0
+  - rio-prettyprint ==0.1.1.0
   - roc-id ==0.1.0.0
   - rocksdb-haskell ==1.0.1
   - rocksdb-query ==0.3.2
···
   - special-values ==0.1.0.0
   - speculate ==0.4.2
   - speedy-slice ==0.3.1
-  - Spintax ==0.3.4
+  - Spintax ==0.3.5
   - splice ==0.6.1.1
   - split ==0.2.3.4
   - splitmix ==0.0.5
···
   - structs ==0.1.3
   - structured ==0.1
   - structured-cli ==2.5.2.0
-  - stylish-haskell ==0.11.0.0
+  - stylish-haskell ==0.11.0.3
   - summoner ==2.0.1.1
   - summoner-tui ==2.0.1.1
   - sum-type-boilerplate ==0.1.1
···
   - syb ==0.7.1
   - symbol ==0.2.4
   - symengine ==0.1.2.0
-  - symmetry-operations-symbols ==0.0.1.4
+  - symmetry-operations-symbols ==0.0.2.1
   - sysinfo ==0.1.1
   - system-argv0 ==0.1.1
   - systemd ==2.3.0
···
   - xdg-userdirs ==0.1.0.2
   - xeno ==0.4.1
   - xls ==0.1.3
-  - xlsx ==0.8.0
+  - xlsx ==0.8.1
   - xlsx-tabular ==0.2.2.1
   - xml ==1.3.14
   - xml-basic ==0.1.3.1
···
   - xxhash-ffi ==0.2.0.0
   - yaml ==0.11.4.0
   - yamlparse-applicative ==0.1.0.1
-  - yesod ==1.6.0.2
+  - yesod ==1.6.1.0
   - yesod-auth ==1.6.10
   - yesod-auth-fb ==1.10.1
   - yesod-auth-hashdb ==1.7.1.2
-  - yesod-bin ==1.6.0.5
+  - yesod-bin ==1.6.0.6
   - yesod-core ==1.6.18
   - yesod-fb ==0.6.1
   - yesod-form ==1.6.7
···
   - zip-archive ==0.4.1
   - zippers ==0.3
   - zip-stream ==0.2.0.1
-  - zlib ==0.6.2.1
+  - zlib ==0.6.2.2
   - zlib-bindings ==0.1.1.5
   - zlib-lens ==0.1.2.1
   - zot ==0.0.3
···
   - deepseq == 1.3.0.1                  # required to build Cabal with GHC 6.12.3
   - dhall == 1.29.0                     # required for spago 0.14.0.
   - doctemplates == 0.8                 # required by pandoc-2.9.x
+  - gi-gdk == 3.0.23                    # required for gi-pango 1.0.23
+  - gi-gtk == 3.0.35                    # required for gi-pango 1.0.23
   - generic-deriving == 1.10.5.*        # new versions don't compile with GHC 7.10.x
   - ghc-check == 0.3.0.1                # only version compatible with ghcide 0.2.0
   - ghc-tcplugins-extra ==0.3.2         # required for polysemy-plugin 0.2.5.0
···
     # - pipes-mongodb
     - streaming-wai
   kiwi:
+    - Unique
     - glirc
+    - matterhorn
     - mattermost-api
     - mattermost-api-qc
   psibi:
···
   - AMI
   - ampersand
   - amqp-conduit
+  - amqp-streamly
   - analyze
   - analyze-client
   - anansi-pandoc
···
   - collections-api
   - collections-base-instances
   - colonnade
+  - Color
   - color-counter
   - colorless
   - colorless-http-client
···
   - CoreDump
   - CoreErlang
   - CoreFoundation
+  - corenlp-parser
   - Coroutine
   - coroutine-enumerator
   - coroutine-iteratee
···
   - crystalfontz
   - cse-ghc-plugin
   - csg
+  - csound-catalog
+  - csound-expression
+  - csound-expression-dynamic
+  - csound-expression-opcodes
+  - csound-expression-typed
+  - csound-sampler
   - CSPM-cspm
   - CSPM-FiringRules
   - CSPM-Frontend
···
   - curve25519
   - curves
   - custom-prelude
+  - cut-the-crap
   - CV
   - cv-combinators
   - cypher
···
   - data-filepath
   - data-fin
   - data-fin-simple
+  - data-fix-cse
   - data-flagset
   - data-forest
   - data-ivar
···
   - dgim
   - dgs
   - dhall-check
+  - dhall-docs
   - dhall-fly
   - dhall-nix
   - dhall-text
···
   - EnumMap
   - enummapmap
   - enummapset-th
+  - env-extra
   - env-parser
   - envstatus
   - epanet-haskell
···
   - EsounD
   - espial
   - ess
-  - essence-of-live-coding
-  - essence-of-live-coding-gloss
-  - essence-of-live-coding-pulse
-  - essence-of-live-coding-quickcheck
   - estimators
   - EstProgress
   - estreps
···
   - findhttp
   - fingertree-psqueue
   - fingertree-tf
-  - finitary
   - finitary-derive
   - finitary-optics
   - FiniteMap
···
   - ghcprofview
   - ght
   - gi-cairo-again
-  - gi-ggit
-  - gi-girepository
-  - gi-graphene
-  - gi-gsk
-  - gi-gst
-  - gi-gstaudio
-  - gi-gstbase
-  - gi-gstpbutils
-  - gi-gsttag
-  - gi-gstvideo
-  - gi-gtkosxapplication
-  - gi-gtksource
-  - gi-handy
-  - gi-harfbuzz
-  - gi-ibus
-  - gi-notify
-  - gi-ostree
-  - gi-pangocairo
-  - gi-poppler
-  - gi-secret
-  - gi-vte
-  - gi-wnck
   - giak
   - Gifcurry
   - ginsu
···
   - gtfs
   - gtfs-realtime
   - gtk-serialized-event
+  - gtk-sni-tray
+  - gtk-strut
   - gtk-toy
   - gtk2hs-hello
   - gtk2hs-rpn
···
   - inilist
   - initialize
   - inject-function
+  - inline-asm
   - inline-java
   - inline-r
   - inserts
···
   - introduction
   - introduction-test
   - intset
-  - invertible-grammar
   - invertible-hlist
   - invertible-syntax
   - io-capture
···
   - marxup
   - masakazu-bot
   - MASMGen
+  - massiv
+  - massiv-io
+  - massiv-test
   - master-plan
   - matchable
   - matchable-th
···
   - matrix-market
   - matrix-sized
   - matsuri
-  - matterhorn
   - maude
   - maxent
   - maxent-learner-hw
···
   - om-actor
   - om-elm
   - om-fail
+  - om-http-logging
   - omaketex
   - ombra
   - Omega
···
   - pg-store
   - pg-transact
   - pgdl
+  - pgf2
   - pgsql-simple
   - pgstream
   - phasechange
···
   - plat
   - platinum-parsing
   - PlayingCards
+  - plex
   - plist
   - plist-buddy
   - plocketed
···
   - scgi
   - schedevr
   - schedule-planner
+  - scheduler
   - schedyield
   - schema
   - schemas
···
   - secure-sockets
   - secureUDP
   - sednaDBXML
+  - seitz-symbol
   - selectors
   - SelectSequencesFromMSA
   - selenium
···
   - setoid
   - setters
   - sexp
-  - sexp-grammar
   - sexpr-parser
   - sext
   - SFML
···
   - streamproc
   - strelka
   - strict-data
+  - strict-lens
+  - strict-optics
   - strict-tuple-lens
   - StrictBench
   - StrictCheck
···
   - swearjure
   - swf
   - swift-lda
+  - swiss-ephemeris
   - sws
   - syb-extras
   - syb-with-class-instances-text
···
   - Tablify
   - tabloid
   - tabs
+  - taffybar
   - tag-bits
   - tag-stream
   - tagged-exception-core
···
   - test-simple
   - testbench
   - testCom
+  - testcontainers
   - TestExplode
   - testloop
   - testpack
···
   - uniform-io
   - union
   - union-map
-  - Unique
   - uniqueid
   - uniquely-represented-sets
   - units-attoparsec

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

···
        benchmarkHaskellDepends = [ base colour criterion deepseq random ];
        description = "Color spaces and conversions between them";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "Color_0_2_0" = callPackage
···
        description = "Color spaces and conversions between them";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "Combinatorrent" = callPackage
···
        pname = "JuicyPixels-blurhash";
        version = "0.1.0.3";
        sha256 = "0kgl2j7990p8q5yrkn0wgaszc9fzva1pc3277j11k1lbjsymz360";
-       revision = "1";
-       editedCabalFile = "05vnd6a4z0r1dg25r2fc2q5krqcw1k0qdxwbhzc7rcnrnnwn0f2d";
+       revision = "2";
+       editedCabalFile = "0phffs6r83sny6zr4zsrppzqy1lgybm6lqgfmbfgwhyvmd544qx6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "Rattus";
-       version = "0.2";
-       sha256 = "0mz6hwg4barn8iszi01lwrkx4i322r5a738kw7sd9mrmdlzd0fh9";
+       version = "0.3";
+       sha256 = "1ks05nn9g6gp3l61bzmphxm9d0ajvlkzaws04fzz73rfv4nb97wg";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          base containers ghc simple-affine-space
···
     ({ mkDerivation, attoparsec, base, extra, mtl, mwc-random, text }:
      mkDerivation {
        pname = "Spintax";
-       version = "0.3.4";
-       sha256 = "008b83nnjgpzjr4c2dk1vambzb78dwx59c5cq4p0s8ghp6xl9sk3";
+       version = "0.3.5";
+       sha256 = "1z5sv03h07bf8z6pzxsia9hgf879cmiqdajvx212dk47lysfnm8v";
        libraryHaskellDepends = [
          attoparsec base extra mtl mwc-random text
        ];
···
      }:
      mkDerivation {
        pname = "Unique";
-       version = "0.4.7.7";
-       sha256 = "05klzscyvqd67rcyhkbx046i860vpxlfzp52yalfqrlvyyfgg3m2";
+       version = "0.4.7.8";
+       sha256 = "0w82pa6r2a6969w251fbrx0sr1ws8mkg2lwdyjl4qjhl5s28k43i";
        libraryHaskellDepends = [
          base containers extra hashable unordered-containers
        ];
···
        ];
        description = "It provides the functionality like unix \"uniq\" utility";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
+       maintainers = with stdenv.lib.maintainers; [ kiwi ];
      }) {};
 
   "Unixutils" = callPackage
···
        sha256 = "1kr3waa46k3619yvif0zh4lx7s0zhyghlr1c5kkrvg432i8wmdm6";
        libraryHaskellDepends = [ aeson base ];
        description = "Compatible generic class names of Aeson";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "aeson-helper" = callPackage
+    ({ mkDerivation, aeson, base, text, unordered-containers, vector }:
+     mkDerivation {
+       pname = "aeson-helper";
+       version = "0.1.0.0";
+       sha256 = "0s4gq827i2wyflcaxbhlr8f8svlw8szzmwax9d7vnxk9wy9fw8w0";
+       libraryHaskellDepends = [
+         aeson base text unordered-containers vector
+       ];
+       description = "Aeson helper func";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "aeson-result" = callPackage
+    ({ mkDerivation, aeson, aeson-helper, base, text }:
+     mkDerivation {
+       pname = "aeson-result";
+       version = "0.1.0.0";
+       sha256 = "10bnzh7vlh42sip0z7mvx5jxrsi7p2s3vqy55pfg2pb17czzly2y";
+       libraryHaskellDepends = [ aeson aeson-helper base text ];
+       description = "API Result for aeson";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "aeson-schema" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
      , directory, fail, filepath, ghc-prim, hashable, hint, HUnit, mtl
···
      }) {};
 
   "aeson-with" = callPackage
-    ({ mkDerivation, aeson, base, hashmap, lens, lens-aeson, mtl
-     , scientific, text, unordered-containers, vector
+    ({ mkDerivation, aeson, base, lens, lens-aeson, scientific, text
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "aeson-with";
-       version = "0.1.1.2";
-       sha256 = "14sj4zx8g03vb4wdvri41yr3rhilczq4chyy7nl4l2wpk58g246c";
+       version = "0.1.2.0";
+       sha256 = "0zj8jjsq26i6k8m3zfszpjxnnkar3gmvdw1adl9rxlgha2v5kfz8";
        libraryHaskellDepends = [
-         aeson base hashmap lens lens-aeson mtl scientific text
-         unordered-containers vector
+         aeson base lens lens-aeson scientific text unordered-containers
+         vector
        ];
        description = "withXField combinators for aeson";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "alarmclock";
-       version = "0.7.0.4";
-       sha256 = "0am8q26yj29k82y9bsgrlqxam1wllzdnxjbwqx4cgmjkzr7x802j";
-       libraryHaskellDepends = [
-         async base clock stm time unbounded-delays
-       ];
-       testHaskellDepends = [
-         async base clock hspec stm time unbounded-delays
-       ];
-       description = "Wake up and perform an action at a certain time";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "alarmclock_0_7_0_5" = callPackage
-    ({ mkDerivation, async, base, clock, hspec, stm, time
-     , unbounded-delays
-     }:
-     mkDerivation {
-       pname = "alarmclock";
        version = "0.7.0.5";
        sha256 = "0197phsc4rn5mn155hbmxplxi2ymra1x6lxq16xs6a8zrk4gfkj9";
        libraryHaskellDepends = [
···
        ];
        description = "Wake up and perform an action at a certain time";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "alea" = callPackage
···
        ];
        description = "A simple streamly wrapper for amqp";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "amqp-utils" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "ansi-terminal_0_11" = callPackage
+    ({ mkDerivation, base, colour }:
+     mkDerivation {
+       pname = "ansi-terminal";
+       version = "0.11";
+       sha256 = "14rp62c7y79n9dmmi7m0l9n3mcq6dh331b4yyyrivm5da6g1nqf6";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base colour ];
+       description = "Simple ANSI terminal support, with Windows compatibility";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "ansi-terminal-game" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, bytestring, cereal
      , clock, exceptions, hspec, linebreak, mintty, mtl, QuickCheck
···
        pname = "ansi-wl-pprint";
        version = "0.6.9";
        sha256 = "1b2fg8px98dzbaqyns10kvs8kn6cl1hdq5wb9saz40izrpkyicm7";
-       revision = "1";
-       editedCabalFile = "0bb5fzjjc00932pny1fql40dmpmikfqzbrbmpwr09bfw9aynvzgn";
+       revision = "2";
+       editedCabalFile = "1xrv66v5hqchjhj8a0g3awy1qpsswk2jqb4w4yh3mm1py5s0dlr0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ ansi-terminal base ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "assert-failure_0_1_2_4" = callPackage
+    ({ mkDerivation, base, pretty-show, text }:
+     mkDerivation {
+       pname = "assert-failure";
+       version = "0.1.2.4";
+       sha256 = "0q4kaaxvz89qrw7j9kgh57nzyn6a8rh2w1hjb1h7ymdnznhr3cj4";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base pretty-show text ];
+       description = "Syntactic sugar improving 'assert' and 'error'";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "assertions" = callPackage
     ({ mkDerivation, ansi-terminal, base, containers, interpolate
      , process
···
     ({ mkDerivation, base, bifunctors, tagged }:
      mkDerivation {
        pname = "assoc";
-       version = "1.0.1";
-       sha256 = "1m9n4vp190bvn2wcrd4ggfwa9pi93jp0zgx02mdgywn2zfidw020";
-       revision = "1";
-       editedCabalFile = "1q6sc9v79p2pdm7aa6mfbn824vc01wj267saf2gp86b3wzgp0mrh";
+       version = "1.0.2";
+       sha256 = "0kqlizznjy94fm8zr1ng633yxbinjff7cnsiaqs7m33ix338v66q";
        libraryHaskellDepends = [ base bifunctors tagged ];
        description = "swap and assoc: Symmetric and Semigroupy Bifunctors";
        license = stdenv.lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
+  "aura_3_1_7" = callPackage
+    ({ mkDerivation, aeson, algebraic-graphs, aur, base, bytestring
+     , containers, filepath, hashable, http-client, http-client-tls
+     , http-types, language-bash, megaparsec, network-uri
+     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
+     , rio, scheduler, stm, tasty, tasty-hunit, text, time, transformers
+     , typed-process, versions
+     }:
+     mkDerivation {
+       pname = "aura";
+       version = "3.1.7";
+       sha256 = "0w7m65bh38gdq186b16pcnq7k2nakiy749m7z092cv4k5w72gal5";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson algebraic-graphs aur base bytestring containers filepath
+         hashable http-client http-types language-bash megaparsec
+         network-uri prettyprinter prettyprinter-ansi-terminal rio scheduler
+         stm text time transformers typed-process versions
+       ];
+       executableHaskellDepends = [
+         aeson aur base bytestring containers http-client http-client-tls
+         megaparsec optparse-applicative prettyprinter
+         prettyprinter-ansi-terminal rio scheduler text transformers
+         typed-process versions
+       ];
+       testHaskellDepends = [
+         base bytestring containers megaparsec rio tasty tasty-hunit text
+         versions
+       ];
+       description = "A secure package manager for Arch Linux and the AUR";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "authenticate" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
      , case-insensitive, conduit, containers, html-conduit, http-conduit
···
        pname = "authenticate-oauth";
        version = "1.6.0.1";
        sha256 = "1hry1zbi7gbyfi94w9cyg6m7ii7xm68jnsph63zxdj2s4ns0ylp0";
-       revision = "1";
-       editedCabalFile = "0pyivmsmlzhpnzpi3jcmqyjjx5a1p7cl1grjyw8571pmxz6735w3";
+       revision = "2";
+       editedCabalFile = "08i6mmk2jqlrd1aksjx02arly7dfpkwc0dwxpr7hs4rbxajbckyr";
        libraryHaskellDepends = [
          base base64-bytestring blaze-builder bytestring crypto-pubkey-types
          data-default http-client http-types random RSA SHA time
···
      }:
      mkDerivation {
        pname = "azimuth-hs";
-       version = "0.1.1";
-       sha256 = "123an5smr2kzxaagnpshh3vcz51p3njkp5hrjcm3x37vr8qrla3x";
+       version = "0.2.1";
+       sha256 = "0gr852mqzd05jhhmszf69r1kk5ja2syq15ac0hdnqzhfzlbq2nrl";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base data-default-class exceptions haskoin-core memory mtl text
···
     ({ mkDerivation, base, containers, hspec, QuickCheck, time }:
      mkDerivation {
        pname = "bank-holidays-england";
-       version = "0.2.0.4";
-       sha256 = "1lqjcpxacjkvgy0900av004xsshyjqx1hq1q0ig42f8r6r4cnf3m";
-       libraryHaskellDepends = [ base containers time ];
-       testHaskellDepends = [ base containers hspec QuickCheck time ];
-       description = "Calculation of bank holidays in England and Wales";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "bank-holidays-england_0_2_0_5" = callPackage
-    ({ mkDerivation, base, containers, hspec, QuickCheck, time }:
-     mkDerivation {
-       pname = "bank-holidays-england";
        version = "0.2.0.5";
        sha256 = "0n7q9s1vsmh5adkhpgycz8y6q49xqf77fpmm73cw0iqgjly4x9hp";
        libraryHaskellDepends = [ base containers time ];
        testHaskellDepends = [ base containers hspec QuickCheck time ];
        description = "Calculation of bank holidays in England and Wales";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "banwords" = callPackage
···
      }:
      mkDerivation {
        pname = "barbies";
-       version = "2.0.1.0";
-       sha256 = "0d2a1d9w8xlviarlrrnlrfs82zf6gzxv09i6sa4ci1bl8df64wmj";
+       version = "2.0.2.0";
+       sha256 = "0x9wn7whn36b4vsaq008zpcw47rs78dfqcysk8x7yhprxbzn7mi2";
        libraryHaskellDepends = [ base distributive transformers ];
        testHaskellDepends = [
          base distributive QuickCheck tasty tasty-hunit tasty-quickcheck
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "base64-bytestring_1_1_0_0" = callPackage
+  "base64-bytestring_1_2_0_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, criterion, deepseq
      , HUnit, QuickCheck, split, test-framework, test-framework-hunit
      , test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "base64-bytestring";
-       version = "1.1.0.0";
-       sha256 = "1adcnkcx4nh3d59k94bkndj0wkgbvchz576qwlpaa7148a86q391";
+       version = "1.2.0.0";
+       sha256 = "1vz4dbbsymjrw5dmb62yw41v126narlb3dpa037hgldlw1fw2iip";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base bytestring containers HUnit QuickCheck split test-framework
···
 
   "battleplace" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cereal, data-default
-     , hashable, memory, servant, text, vector
+     , hashable, memory, servant, swagger2, template-haskell, text
+     , vector
      }:
      mkDerivation {
        pname = "battleplace";
-       version = "0.1.0.9";
-       sha256 = "1m6nk9zjsckd3s27hmmr2jy6v28bp7n1d6wriqfmhzw7rzydrgjl";
+       version = "0.1.0.10";
+       sha256 = "0a1a7bw30wz0hv5n78l58h5qmr6k5x58dnijll7dgksm51g7c3j8";
        libraryHaskellDepends = [
          aeson base bytestring cereal data-default hashable memory servant
-         text vector
+         swagger2 template-haskell text vector
        ];
        description = "Core definitions for BattlePlace.io service";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "bishbosh";
-       version = "0.0.0.5";
-       sha256 = "0i05xbld89ws9bzp9ynr9ly2jy0gw3nvikpbj61i669n9yazps90";
+       version = "0.0.0.6";
+       sha256 = "0gax0q1i86m0zb3gwfwmy59z8jnpri96dd9y73xbjyy4cjnwc32m";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "blank-canvas";
        version = "0.7.1";
        sha256 = "02w428jpb49yaqzw93121lf1m4pjxi8wniqhnrvqh2zh63gsfws1";
-       revision = "2";
-       editedCabalFile = "0rvdgsmlfkk135qx0y0df5r7sw9xv5i89r84q5ylf32icsivlrr7";
+       revision = "3";
+       editedCabalFile = "1l2xcvms2jw10c4jvnc3kldk21vqcchckms0bawrcf908yhq525g";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base base-compat-batteries base64-bytestring bytestring
···
        broken = true;
      }) {};
 
+  "blucontrol" = callPackage
+    ({ mkDerivation, base, containers, data-default, deepseq, directory
+     , filepath, finite-typelits, hspec, libX11, libXrandr, lifted-base
+     , monad-control, mtl, process, QuickCheck, text, time, transformers
+     , transformers-base, unix, X11
+     }:
+     mkDerivation {
+       pname = "blucontrol";
+       version = "0.2.1.1";
+       sha256 = "087bk9fxjgavrprba7ffyb91jv7ms8k7mlq9s5963lkpdf5636n7";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers data-default deepseq directory filepath
+         finite-typelits lifted-base monad-control mtl process text time
+         transformers transformers-base unix X11
+       ];
+       librarySystemDepends = [ libX11 libXrandr ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base data-default deepseq hspec mtl QuickCheck time
+       ];
+       description = "Configurable blue light filter";
+       license = stdenv.lib.licenses.bsd3;
+     }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXrandr;};
+
   "bludigon" = callPackage
     ({ mkDerivation, base, containers, data-default, deepseq, directory
      , filepath, finite-typelits, hspec, libX11, libXrandr, lifted-base
···
      }:
      mkDerivation {
        pname = "bludigon";
-       version = "0.1.0.1";
-       sha256 = "1c0a6a6ir09vxdjv6nx94c73q381c1wbyf4s7p13cah2zh0y4gw4";
+       version = "0.1.1.0";
+       sha256 = "1l6rc79wb9822qjrs9zvm53qp6dd0h8lp5sln55wqa0qzq5xq9mk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "brick";
        version = "0.55";
        sha256 = "0n51vh8j75a2b6qbfah9k9zrp15m4rkq7fywpp811v93h8zf02fy";
+       revision = "1";
+       editedCabalFile = "1kn5nksvds8njy8zv7bq7gankngfam3dl1if0qvlhsfdl3n3d1zr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, bson, ghc-prim, text }:
      mkDerivation {
        pname = "bson-generic";
-       version = "0.0.8.1";
-       sha256 = "0zl74si1cxpdj3sl7mmrdsdjk8iqpy14y6bgjhj350bx1hb8v7wv";
+       version = "0.0.9";
+       sha256 = "11a8k6rngz5rdgccwnifiydsfc87hlgy4mp6chi30m2jvdq92imb";
        libraryHaskellDepends = [ base bson ghc-prim text ];
        description = "Generic functionality for BSON";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "bugzilla-redhat";
        version = "0.3.0";
        sha256 = "1d751f1219ivx9bfdl7xb89w2vns07ciqp4cqcykixnllx2jx18y";
+       revision = "1";
+       editedCabalFile = "145sdnk28sxwz4s1gh0qq6vzm9q6s5433q6w1199cv9585b53kcx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "chart-svg-various";
-       version = "0.0.1";
-       sha256 = "0ajmm6xhzxay715c4zds6lcjnhp8l9qf78rzhymd4hc6vz9v0pi1";
+       version = "0.0.2";
+       sha256 = "0ckh66pm4f3wp2w08z8bfjbwbxssp74g5chwpk9q9n786iaq9x90";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "compact-sequences" = callPackage
+    ({ mkDerivation, base, containers, primitive, transformers }:
+     mkDerivation {
+       pname = "compact-sequences";
+       version = "0.1.0.0";
+       sha256 = "148zjnnnn82vgn4ybs5z6nx9xv2wd73q2cavaa2nyjn1kcqqw7a8";
+       libraryHaskellDepends = [ base containers primitive transformers ];
+       testHaskellDepends = [ base ];
+       description = "Stacks and queues with compact representations";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "compact-socket" = callPackage
     ({ mkDerivation, base, binary, bytestring, compact, deepseq
      , directory, filepath, network, unix
···
      }:
      mkDerivation {
        pname = "core-data";
-       version = "0.2.1.7";
-       sha256 = "19fcbp6ccwggpv1lm1z03m3innk9agiwbz03whiivr3zg2gzcglh";
-       libraryHaskellDepends = [
-         aeson base bytestring containers core-text hashable prettyprinter
-         prettyprinter-ansi-terminal scientific text unordered-containers
-         vector
-       ];
-       description = "Convenience wrappers around common data structures and encodings";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "core-data_0_2_1_8" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, core-text
-     , hashable, prettyprinter, prettyprinter-ansi-terminal, scientific
-     , text, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "core-data";
        version = "0.2.1.8";
        sha256 = "1hgvvkk3m3ykdndmf2hbm59v0pim68jwgl2a6n5hw1dv4xwd3fay";
        libraryHaskellDepends = [
···
        ];
        description = "Convenience wrappers around common data structures and encodings";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "core-haskell" = callPackage
···
      }:
      mkDerivation {
        pname = "core-program";
-       version = "0.2.4.4";
-       sha256 = "1mkhwfw4h5q2dly1gm082k3s9jsq2wb0xksfa6xv8ghvxpvypvck";
-       libraryHaskellDepends = [
-         async base bytestring chronologique core-data core-text directory
-         exceptions filepath fsnotify hashable hourglass mtl prettyprinter
-         prettyprinter-ansi-terminal safe-exceptions stm template-haskell
-         terminal-size text text-short transformers unix
-       ];
-       description = "Opinionated Haskell Interoperability";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "core-program_0_2_4_5" = callPackage
-    ({ mkDerivation, async, base, bytestring, chronologique, core-data
-     , core-text, directory, exceptions, filepath, fsnotify, hashable
-     , hourglass, mtl, prettyprinter, prettyprinter-ansi-terminal
-     , safe-exceptions, stm, template-haskell, terminal-size, text
-     , text-short, transformers, unix
-     }:
-     mkDerivation {
-       pname = "core-program";
        version = "0.2.4.5";
        sha256 = "1a2zjdywmgniwcj649f43hri55bh30vz2s00r3yqj3gvhhighi86";
        libraryHaskellDepends = [
···
        ];
        description = "Opinionated Haskell Interoperability";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "core-text" = callPackage
···
      }:
      mkDerivation {
        pname = "core-text";
-       version = "0.2.3.5";
-       sha256 = "085w21vh5rgl1pc7731ih47gh8gszjj0xfgkr3acy0r9rbh33m9c";
-       libraryHaskellDepends = [
-         base bytestring deepseq fingertree hashable prettyprinter
-         prettyprinter-ansi-terminal template-haskell text text-short
-       ];
-       description = "A rope type based on a finger tree over UTF-8 fragments";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "core-text_0_2_3_6" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, fingertree, hashable
-     , prettyprinter, prettyprinter-ansi-terminal, template-haskell
-     , text, text-short
-     }:
-     mkDerivation {
-       pname = "core-text";
        version = "0.2.3.6";
        sha256 = "13sdgym8xhljpc465bq1h066mrcvk77568viklhib255skjl56gn";
        libraryHaskellDepends = [
···
        ];
        description = "A rope type based on a finger tree over UTF-8 fragments";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "corebot-bliki" = callPackage
···
        librarySystemDepends = [ rocksdb ];
        description = "Launches CoreNLP and parses the JSON output";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) rocksdb;};
 
   "cornea" = callPackage
···
        ];
        description = "a gallery of Csound instruments";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "csound-expression" = callPackage
···
        ];
        description = "library to make electronic music";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "csound-expression-dynamic" = callPackage
···
        ];
        description = "dynamic core for csound-expression library";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "csound-expression-opcodes" = callPackage
···
        ];
        description = "opcodes for the library csound-expression";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "csound-expression-typed" = callPackage
···
        ];
        description = "typed core for the library csound-expression";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "csound-sampler" = callPackage
···
        libraryHaskellDepends = [ base csound-expression transformers ];
        description = "A musical sampler based on Csound";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "csp" = callPackage
···
        testPkgconfigDepends = [ pocketsphinx sphinxbase ];
        description = "Cuts out uninteresting parts of videos by detecting silences";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) pocketsphinx; inherit (pkgs) sphinxbase;};
 
   "cutter" = callPackage
···
 
   "darcs" = callPackage
     ({ mkDerivation, array, async, attoparsec, base, base16-bytestring
-     , binary, bytestring, Cabal, cmdargs, containers, cryptohash, curl
-     , data-ordlist, directory, fgl, filepath, FindBin, graphviz
-     , hashable, haskeline, html, HTTP, HUnit, mmap, mtl, network
-     , network-uri, old-time, parsec, process, QuickCheck, random
-     , regex-applicative, regex-compat-tdfa, sandi, shelly, split, stm
-     , tar, terminfo, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, text, time, transformers, unix
-     , unix-compat, utf8-string, vector, zip-archive, zlib
+     , binary, bytestring, Cabal, cmdargs, conduit, constraints
+     , containers, cryptonite, data-ordlist, directory, fgl, filepath
+     , FindBin, hashable, haskeline, html, http-conduit, http-types
+     , HUnit, leancheck, memory, mmap, mtl, network, network-uri
+     , old-time, parsec, process, QuickCheck, regex-applicative
+     , regex-compat-tdfa, sandi, shelly, split, stm, tar, temporary
+     , terminfo, test-framework, test-framework-hunit
+     , test-framework-leancheck, test-framework-quickcheck2, text, time
+     , transformers, unix, unix-compat, utf8-string, vector, zip-archive
+     , zlib
      }:
      mkDerivation {
        pname = "darcs";
-       version = "2.14.4";
-       sha256 = "0qk70a2i5p69lai0vzrckjql3rz8sfiq5vnpafmscmq8018i2wp7";
+       version = "2.16.1";
+       sha256 = "1q837ibf97f3fm6gcr5l6cc4kb554gm1fhzc2a22fkkj15axivq0";
        configureFlags = [ "-fforce-char8-encoding" "-flibrary" ];
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal directory filepath process ];
        libraryHaskellDepends = [
          array async attoparsec base base16-bytestring binary bytestring
-         containers cryptohash data-ordlist directory fgl filepath graphviz
-         hashable haskeline html HTTP mmap mtl network network-uri old-time
-         parsec process random regex-applicative regex-compat-tdfa sandi stm
-         tar terminfo text time transformers unix unix-compat utf8-string
-         vector zip-archive zlib
+         conduit constraints containers cryptonite data-ordlist directory
+         fgl filepath hashable haskeline html http-conduit http-types memory
+         mmap mtl network network-uri old-time parsec process
+         regex-applicative regex-compat-tdfa sandi stm tar temporary
+         terminfo text time transformers unix unix-compat utf8-string vector
+         zip-archive zlib
        ];
-       librarySystemDepends = [ curl ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
-         array base bytestring cmdargs containers directory filepath FindBin
-         HUnit mtl QuickCheck shelly split test-framework
-         test-framework-hunit test-framework-quickcheck2 text transformers
-         zip-archive
+         array base bytestring cmdargs constraints containers directory
+         filepath FindBin HUnit leancheck mtl QuickCheck shelly split
+         test-framework test-framework-hunit test-framework-leancheck
+         test-framework-quickcheck2 text transformers vector zip-archive
        ];
        doCheck = false;
        postInstall = ''
···
          mv contrib/darcs_completion $out/etc/bash_completion.d/darcs
        '';
        description = "a distributed, interactive, smart revision control system";
-       license = stdenv.lib.licenses.gpl2;
-     }) {inherit (pkgs) curl;};
+       license = stdenv.lib.licenses.gpl2Plus;
+     }) {};
 
   "darcs-benchmark" = callPackage
     ({ mkDerivation, base, bytestring, cmdargs, containers, datetime
···
        libraryHaskellDepends = [ base containers data-fix transformers ];
        description = "Common subexpression elimination for the fixploint types";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "data-flags" = callPackage
···
        pname = "dhall";
        version = "1.34.0";
        sha256 = "0rqvzvcqbhs9gvga7api6jjblnypm4a33z8kxi578ps63mhn3g0d";
+       revision = "1";
+       editedCabalFile = "0d5rqjalz6clvbmnqmpsy4dl9zj1magwmd1gdl2vzkf5qnhp6n7r";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "Generate HTML docs from a dhall package";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "dhall-fly" = callPackage
···
        pname = "dhall-json";
        version = "1.7.1";
        sha256 = "158c9vhxa124r1xqn365wvwqhby5rngkip08ghy8rnjs5ijcxzgf";
+       revision = "2";
+       editedCabalFile = "12piijva2szd08c6pgr6qca4kmf48il8934iv0k51jfyfd1m01ic";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dhall-lsp-server";
        version = "1.0.9";
        sha256 = "0zf53pc8rxapmdm9fvp04gfnw2910yv1gm5sm5v5wb606njzk0xn";
+       revision = "1";
+       editedCabalFile = "1ml2yhwwbwwdv13266fgjk39pk04hg0ak82y08aixcryaldfhgwi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dhall-yaml";
        version = "1.2.1";
        sha256 = "18p8a92wiz2zi4q7v5fjvdallxrl21scmwwv706g3mm5dgfgcs5a";
+       revision = "1";
+       editedCabalFile = "037zg3ick95pwsk2g0znhfdvwphw3yxv5kp8zj5czc6df97id8xj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dlist-nonempty";
        version = "0.1.1";
        sha256 = "0csbspdy43pzvasb5mhs5pz2f49ws78pi253cx7pp84wjx6ads20";
-       revision = "8";
-       editedCabalFile = "134fcrv7lmbhzmgp07vp3fdjbbjrkkracvjf6ma5k2fwcw0wfkff";
+       revision = "9";
+       editedCabalFile = "09qgsqzjnkr5d2lwdz86q3zrikd5hacd62hvvfdqy39kh5wrqn4y";
        libraryHaskellDepends = [
          base base-compat deepseq dlist semigroupoids
        ];
···
     ({ mkDerivation, base, mmsyn3, mmsyn6ukr, mmsyn7s, vector }:
      mkDerivation {
        pname = "dobutokO-poetry";
-       version = "0.9.0.1";
-       sha256 = "1wjxmlcz5xyc3avfm9f74f3scjjqa3a8hn0pav2l0lhkf8r6p5i6";
+       version = "0.10.0.0";
+       sha256 = "1lrdlgn49im8rgvsj61k2n3g2ham2gizbv0r95nv4ga71z54lyhj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mmsyn3 mmsyn6ukr mmsyn7s vector ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "dotenv_0_8_0_6" = callPackage
+    ({ mkDerivation, base, base-compat, containers, directory
+     , exceptions, hspec, hspec-megaparsec, megaparsec
+     , optparse-applicative, process, text, transformers, yaml
+     }:
+     mkDerivation {
+       pname = "dotenv";
+       version = "0.8.0.6";
+       sha256 = "0ndgsjjcpmhxaxjn4mmw4cyd6i2y67zpx9ap099k5jw9ad0lbwb0";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base base-compat containers directory exceptions megaparsec process
+         text transformers yaml
+       ];
+       executableHaskellDepends = [
+         base base-compat megaparsec optparse-applicative process text
+         transformers yaml
+       ];
+       testHaskellDepends = [
+         base base-compat containers directory exceptions hspec
+         hspec-megaparsec megaparsec process text transformers yaml
+       ];
+       description = "Loads environment variables from dotenv files";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "dotfs" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
      , haskell-src, HFuse, HUnit, parsec, process, QuickCheck
···
      }) {};
 
   "egison-pattern-src-th-mode" = callPackage
-    ({ mkDerivation, base, egison-pattern-src, haskell-src-exts
-     , haskell-src-meta, mtl, pretty, tasty, tasty-discover, tasty-hunit
-     , template-haskell, text
-     }:
-     mkDerivation {
-       pname = "egison-pattern-src-th-mode";
-       version = "0.2.1.0";
-       sha256 = "0libfs39irdnqfvynmpji21p6nyk2s3zsxhlmsz763aya51ymxpy";
-       revision = "2";
-       editedCabalFile = "1ad2iii6csindqy9kd47zs1c04qj9fyg93iji5fxrb4wgmc90l2a";
-       libraryHaskellDepends = [
-         base egison-pattern-src haskell-src-exts haskell-src-meta mtl
-         pretty template-haskell text
-       ];
-       testHaskellDepends = [
-         base egison-pattern-src haskell-src-exts mtl tasty tasty-hunit
-         template-haskell text
-       ];
-       testToolDepends = [ tasty-discover ];
-       description = "Parser and pretty printer for Egison pattern expressions to use with TH";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "egison-pattern-src-th-mode_0_2_1_1" = callPackage
     ({ mkDerivation, base, egison-pattern-src, haskell-src-exts
      , haskell-src-meta, mtl, pretty, tasty, tasty-discover, tasty-hunit
      , template-haskell, text
···
        testToolDepends = [ tasty-discover ];
        description = "Parser and pretty printer for Egison pattern expressions to use with TH";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "egison-quote" = callPackage
···
        ];
        description = "Safe helpers for accessing and modifying environment variables";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "env-locale" = callPackage
···
        ];
        description = "General purpose live coding framework";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "essence-of-live-coding_0_2_1" = callPackage
+    ({ mkDerivation, base, containers, foreign-store, mtl, QuickCheck
+     , syb, test-framework, test-framework-quickcheck2, transformers
+     , vector-sized
+     }:
+     mkDerivation {
+       pname = "essence-of-live-coding";
+       version = "0.2.1";
+       sha256 = "1bjpzz5ph2n4ljhckn2p88pg6c49phigw2f1y9l83wgnvdavdz83";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers foreign-store syb transformers vector-sized
+       ];
+       executableHaskellDepends = [ base transformers ];
+       testHaskellDepends = [
+         base containers mtl QuickCheck syb test-framework
+         test-framework-quickcheck2 transformers
+       ];
+       description = "General purpose live coding framework";
+       license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "essence-of-live-coding-gloss" = callPackage
···
        ];
        description = "General purpose live coding framework - Gloss backend";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "essence-of-live-coding-gloss_0_2_1" = callPackage
+    ({ mkDerivation, base, essence-of-live-coding, foreign-store, gloss
+     , syb, transformers
+     }:
+     mkDerivation {
+       pname = "essence-of-live-coding-gloss";
+       version = "0.2.1";
+       sha256 = "0pgkzfy7w8lylx0bb3vs1d8a2hgaavn2m9rj0v1f6hl193hnimz7";
+       libraryHaskellDepends = [
+         base essence-of-live-coding foreign-store gloss syb transformers
+       ];
+       description = "General purpose live coding framework - Gloss backend";
+       license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
+     }) {};
+
+  "essence-of-live-coding-gloss-example" = callPackage
+    ({ mkDerivation, base, essence-of-live-coding
+     , essence-of-live-coding-gloss, gloss, syb, transformers
+     }:
+     mkDerivation {
+       pname = "essence-of-live-coding-gloss-example";
+       version = "0.2.1";
+       sha256 = "0rfpl2y6dga86qpq3sfc1kvwsb55d3aw0ckkfn8yflfnad6k884l";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base essence-of-live-coding essence-of-live-coding-gloss gloss syb
+         transformers
+       ];
+       description = "General purpose live coding framework - Gloss example";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "essence-of-live-coding-pulse" = callPackage
···
        ];
        description = "General purpose live coding framework - pulse backend";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "essence-of-live-coding-pulse_0_2_1" = callPackage
+    ({ mkDerivation, base, essence-of-live-coding, foreign-store
+     , pulse-simple, transformers
+     }:
+     mkDerivation {
+       pname = "essence-of-live-coding-pulse";
+       version = "0.2.1";
+       sha256 = "02my8bprwij9rxl0x0yb8q9zr137alzl77j5lvd1gl5r5sbvm8pj";
+       libraryHaskellDepends = [
+         base essence-of-live-coding foreign-store pulse-simple transformers
+       ];
+       description = "General purpose live coding framework - pulse backend";
+       license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
+     }) {};
+
+  "essence-of-live-coding-pulse-example" = callPackage
+    ({ mkDerivation, base, essence-of-live-coding
+     , essence-of-live-coding-pulse, pulse-simple, transformers, vector
+     }:
+     mkDerivation {
+       pname = "essence-of-live-coding-pulse-example";
+       version = "0.2.1";
+       sha256 = "118xlqx67lgyrqi9r581ad2xsqs5x5d19afbfh6200bi618sr8af";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base essence-of-live-coding essence-of-live-coding-pulse
+         pulse-simple transformers vector
+       ];
+       description = "General purpose live coding framework - pulse backend example";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "essence-of-live-coding-quickcheck" = callPackage
···
        ];
        description = "General purpose live coding framework - QuickCheck integration";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "essence-of-live-coding-quickcheck_0_2_1" = callPackage
+    ({ mkDerivation, base, boltzmann-samplers, essence-of-live-coding
+     , QuickCheck, syb, transformers
+     }:
+     mkDerivation {
+       pname = "essence-of-live-coding-quickcheck";
+       version = "0.2.1";
+       sha256 = "144840ck2a0wk8pd62c6l9iw6jlvva3yif30mba9m8r1zylaanyj";
+       libraryHaskellDepends = [
+         base boltzmann-samplers essence-of-live-coding QuickCheck syb
+         transformers
+       ];
+       description = "General purpose live coding framework - QuickCheck integration";
+       license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "estimator" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "extra_1_7_5" = callPackage
+    ({ mkDerivation, base, clock, directory, filepath, process
+     , QuickCheck, quickcheck-instances, time, unix
+     }:
+     mkDerivation {
+       pname = "extra";
+       version = "1.7.5";
+       sha256 = "1cickrjvg4i25yn3qg4f0id0bmq115siysyqnh0yk9rwjlnrxyn9";
+       libraryHaskellDepends = [
+         base clock directory filepath process time unix
+       ];
+       testHaskellDepends = [
+         base directory filepath QuickCheck quickcheck-instances unix
+       ];
+       description = "Extra functions I use";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "extract-dependencies" = callPackage
     ({ mkDerivation, async, base, Cabal, containers
      , package-description-remote
···
      }) {};
 
   "fakefs" = callPackage
-    ({ mkDerivation, base, containers, hspec, mtl, QuickCheck }:
+    ({ mkDerivation, base, containers, exceptions, hspec, mtl
+     , QuickCheck
+     }:
      mkDerivation {
        pname = "fakefs";
-       version = "0.2.0.1";
-       sha256 = "0szdjrc4m87h9dsb7qg5rpp5avnyzv47mymyihgvmxc22wiyf1c1";
-       libraryHaskellDepends = [ base containers mtl ];
-       testHaskellDepends = [ base containers hspec QuickCheck ];
+       version = "0.3.0.1";
+       sha256 = "1vilfl6vgxcywg81xfy6w6lir6r5pky7f2p7mf196kjby630av05";
+       libraryHaskellDepends = [ base containers exceptions mtl ];
+       testHaskellDepends = [
+         base containers exceptions hspec QuickCheck
+       ];
        description = "Extensible fake file system for testing";
        license = stdenv.lib.licenses.asl20;
      }) {};
···
      }:
      mkDerivation {
        pname = "ffunctor";
-       version = "1.2.0";
-       sha256 = "0rq60a7ximvqdxqvijw1isd1d5gwqbjagmws91y0jvxlwmsgzf6w";
-       revision = "2";
-       editedCabalFile = "1mwddp63jdgfzhdcyqs77nv5lsbaw4gj63gcihimfmj5qxlx7zpk";
+       version = "1.2.1";
+       sha256 = "0143i0l4153k1pkql50hb158hcx9iqjj59zwqlhbqq0rr43nza3f";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [
          aeson base exceptions generic-lens http-client mtl servant
···
      }:
      mkDerivation {
        pname = "fgl";
-       version = "5.7.0.2";
-       sha256 = "13zqdwj6j2y5827w3dcx8kl1gini4x938bfh4c5g5jc3b37rlnll";
-       libraryHaskellDepends = [
-         array base containers deepseq transformers
-       ];
-       testHaskellDepends = [ base containers hspec QuickCheck ];
-       benchmarkHaskellDepends = [ base deepseq microbench ];
-       description = "Martin Erwig's Functional Graph Library";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "fgl_5_7_0_3" = callPackage
-    ({ mkDerivation, array, base, containers, deepseq, hspec
-     , microbench, QuickCheck, transformers
-     }:
-     mkDerivation {
-       pname = "fgl";
        version = "5.7.0.3";
        sha256 = "04k5grp5d381wkc7sxgcl0sd3z3nlm6l6mmh103vhzh6p49vhs99";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base deepseq microbench ];
        description = "Martin Erwig's Functional Graph Library";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "fgl-arbitrary" = callPackage
···
        ];
        description = "A better, more type-safe Enum";
        license = stdenv.lib.licenses.gpl3Plus;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "finitary-derive" = callPackage
···
      }:
      mkDerivation {
        pname = "fishfood";
-       version = "0.0.1.10";
-       sha256 = "075hqpp4jmhl57a6y5vgnmxc3264mby2xpcmskxpcrqf6isbljah";
+       version = "0.0.1.11";
+       sha256 = "005jljanccyxj7j7lnkralir1lcinka5kapw0nv39pd1ibyc1nrb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "functor-combinators";
-       version = "0.3.0.0";
-       sha256 = "0bqlmxgq9as0ij11ir2licj3jkq190g56rdrf2g4hsjvk9xjsdkm";
+       version = "0.3.3.0";
+       sha256 = "1qym0xn4ydj2vx6nhy26k4bwznjjx7spgr0pv33b2i5wpznn972z";
        libraryHaskellDepends = [
          assoc base bifunctors comonad constraints containers contravariant
          deriving-compat free invariant kan-extensions mmorph mtl
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "generic-data_0_9_0_0" = callPackage
+  "generic-data_0_9_1_0" = callPackage
     ({ mkDerivation, ap-normalize, base, base-orphans, Cabal
      , cabal-doctest, contravariant, criterion, deepseq, doctest
      , generic-lens, ghc-boot-th, inspection-testing, one-liner
···
      }:
      mkDerivation {
        pname = "generic-data";
-       version = "0.9.0.0";
-       sha256 = "1w8qkrl38p2fc38xbhgb973jd0czvm2f3707iqknj7rxf0xhjcfn";
+       version = "0.9.1.0";
+       sha256 = "0p58z70wp3vapxrwg7hkr5n6px7hws9398v9shc08c2aigq36kqa";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          ap-normalize base base-orphans contravariant ghc-boot-th
···
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "8.10.1.20200523";
-       sha256 = "0qqcygmndgpmjm7hdr81bj298mc0gmnswm4i14r0fwnyc00zr4yy";
-       revision = "1";
-       editedCabalFile = "1hs46w2h5wz2gvdmhqvkyl413jryba8gbpbg23hjrsz5c1divym7";
+       version = "8.10.2.20200808";
+       sha256 = "0vh941bk7fy44rn5hwqa25xbfyhm28wcy4nwpvm3291lp0cxndgh";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
···
      }:
      mkDerivation {
        pname = "ghc-lib-parser";
-       version = "8.10.1.20200523";
-       sha256 = "1g2jki7f1in5c2y80zhz3hxrm4c7m063slxpg1lrvqrgrlwag5cb";
-       revision = "1";
-       editedCabalFile = "18q82c1iixph91kaypa2dzbcjf1dl46w1i5ckifgmdqh9zxibs9c";
+       version = "8.10.2.20200808";
+       sha256 = "0nfxsvpsiyxbjc3hvdax70z07k08bc255lz9jhqgq57lnw46dyfl";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
···
      }:
      mkDerivation {
        pname = "ghc-lib-parser-ex";
-       version = "8.10.0.15";
-       sha256 = "1i4xslw53bijvbvba4h0b8c9cy0zr2d4gzm3dfxizss1bz8qcscn";
+       version = "8.10.0.16";
+       sha256 = "1kqff62ml38hxwfnfq7ni0z65b3d3l7xqa5c5lxf3kzm9h7bdwb8";
        libraryHaskellDepends = [
          base bytestring containers ghc-lib-parser uniplate
        ];
···
      }:
      mkDerivation {
        pname = "ghc-tags-core";
-       version = "0.2.2.0";
-       sha256 = "1hnknqqswn3w1l6bk70b44vhbyf43yh0zjfcgsjj1sc2864jikpb";
+       version = "0.2.3.0";
+       sha256 = "0hpk3131dq07m92h6ppacgbj4ar475zrlsj2vhqgpmdh3z9lnd9c";
        libraryHaskellDepends = [
          attoparsec base bytestring directory filepath-bytestring ghc mtl
          pipes pipes-attoparsec pipes-bytestring text transformers
···
      }:
      mkDerivation {
        pname = "ghc-tags-plugin";
-       version = "0.2.2.0";
-       sha256 = "0gsvhljr8q2a8w8va4c3ggghpvhny3ip2vh2vaizl9806126i7q7";
+       version = "0.2.3.0";
+       sha256 = "19bkn5lp1n993jxn4mhmnyw36d1vjwbvhlr1r6ywnanis9vgrbzg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.lgpl21;
      }) {inherit (pkgs) gtk3;};
 
+  "gi-gdk_3_0_23" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, gi-cairo
+     , gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-pango, gtk3
+     , haskell-gi, haskell-gi-base, haskell-gi-overloading, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "gi-gdk";
+       version = "3.0.23";
+       sha256 = "18v3kb6kmryymmrz0d88nf25priwyh3yzh7raghc5ph2rv7n4w8m";
+       setupHaskellDepends = [
+         base Cabal gi-cairo gi-gdkpixbuf gi-gio gi-glib gi-gobject gi-pango
+         haskell-gi
+       ];
+       libraryHaskellDepends = [
+         base bytestring containers gi-cairo gi-gdkpixbuf gi-gio gi-glib
+         gi-gobject gi-pango haskell-gi haskell-gi-base
+         haskell-gi-overloading text transformers
+       ];
+       libraryPkgconfigDepends = [ gtk3 ];
+       description = "Gdk bindings";
+       license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs) gtk3;};
+
   "gi-gdk_4_0_2" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-cairo
      , gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-pango, gtk4
···
        libraryPkgconfigDepends = [ libgit2-glib ];
        description = "libgit2-glib bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) libgit2-glib;};
 
   "gi-gio" = callPackage
···
        libraryPkgconfigDepends = [ gobject-introspection ];
        description = "GIRepository (gobject-introspection) bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) gobject-introspection;};
 
   "gi-glib" = callPackage
···
        libraryPkgconfigDepends = [ graphene-gobject ];
        description = "Graphene bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {graphene-gobject = null;};
 
   "gi-graphene_1_0_2" = callPackage
···
        description = "Graphene bindings";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {graphene-gobject = null;};
 
   "gi-gsk" = callPackage
···
        libraryPkgconfigDepends = [ gtk4 ];
        description = "Gsk bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {gtk4 = null;};
 
   "gi-gst" = callPackage
···
        libraryPkgconfigDepends = [ gstreamer ];
        description = "GStreamer bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs.gst_all_1) gstreamer;};
 
   "gi-gstaudio" = callPackage
···
        libraryPkgconfigDepends = [ gst-plugins-base ];
        description = "GStreamerAudio bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs.gst_all_1) gst-plugins-base;};
 
   "gi-gstbase" = callPackage
···
        libraryPkgconfigDepends = [ gst-plugins-base ];
        description = "GStreamerBase bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs.gst_all_1) gst-plugins-base;};
 
   "gi-gstpbutils" = callPackage
···
        libraryPkgconfigDepends = [ gstreamer-pbutils ];
        description = "GStreamer Plugins Base Utils bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {gstreamer-pbutils = null;};
 
   "gi-gsttag" = callPackage
···
        libraryPkgconfigDepends = [ gstreamer-tag ];
        description = "GStreamer Tag bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {gstreamer-tag = null;};
 
   "gi-gstvideo" = callPackage
···
        libraryPkgconfigDepends = [ gst-plugins-base ];
        description = "GStreamerVideo bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs.gst_all_1) gst-plugins-base;};
 
   "gi-gtk" = callPackage
···
        license = stdenv.lib.licenses.lgpl21;
      }) {inherit (pkgs) gtk3;};
 
+  "gi-gtk_3_0_35" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
+     , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject
+     , gi-pango, gtk3, haskell-gi, haskell-gi-base
+     , haskell-gi-overloading, text, transformers
+     }:
+     mkDerivation {
+       pname = "gi-gtk";
+       version = "3.0.35";
+       sha256 = "08z6kc9m7xb24d9z08yy3g66l8i7nircnaiy5i82yfl2l4slvz2w";
+       setupHaskellDepends = [
+         base Cabal gi-atk gi-cairo gi-gdk gi-gdkpixbuf gi-gio gi-glib
+         gi-gobject gi-pango haskell-gi
+       ];
+       libraryHaskellDepends = [
+         base bytestring containers gi-atk gi-cairo gi-gdk gi-gdkpixbuf
+         gi-gio gi-glib gi-gobject gi-pango haskell-gi haskell-gi-base
+         haskell-gi-overloading text transformers
+       ];
+       libraryPkgconfigDepends = [ gtk3 ];
+       description = "Gtk bindings";
+       license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs) gtk3;};
+
   "gi-gtk_4_0_2" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
      , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject
···
        libraryPkgconfigDepends = [ gtk-mac-integration-gtk3 ];
        description = "GtkosxApplication bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {gtk-mac-integration-gtk3 = null;};
 
   "gi-gtksource" = callPackage
···
        libraryPkgconfigDepends = [ gtksourceview3 ];
        description = "GtkSource bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) gtksourceview3;};
 
   "gi-handy" = callPackage
···
        libraryPkgconfigDepends = [ libhandy ];
        description = "libhandy bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) libhandy;};
 
   "gi-harfbuzz" = callPackage
···
        libraryPkgconfigDepends = [ harfbuzz harfbuzz-gobject ];
        description = "HarfBuzz bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) harfbuzz; harfbuzz-gobject = null;};
 
   "gi-ibus" = callPackage
···
        libraryPkgconfigDepends = [ ibus ];
        description = "IBus bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) ibus;};
 
   "gi-javascriptcore" = callPackage
···
        libraryPkgconfigDepends = [ libnotify ];
        description = "Libnotify bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) libnotify;};
 
   "gi-ostree" = callPackage
···
        description = "OSTree bindings";
        license = stdenv.lib.licenses.lgpl21;
        platforms = [ "i686-linux" "x86_64-linux" ];
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) ostree;};
 
   "gi-pango" = callPackage
···
        '';
        description = "PangoCairo bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) cairo; inherit (pkgs) pango;};
 
   "gi-poppler" = callPackage
···
        libraryPkgconfigDepends = [ poppler ];
        description = "Poppler bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) poppler;};
 
   "gi-secret" = callPackage
···
        libraryPkgconfigDepends = [ libsecret ];
        description = "Libsecret bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) libsecret;};
 
   "gi-soup" = callPackage
···
        libraryPkgconfigDepends = [ vte_291 ];
        description = "Vte bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {vte_291 = pkgs.vte;};
 
   "gi-webkit" = callPackage
···
        libraryPkgconfigDepends = [ libwnck ];
        description = "Wnck bindings";
        license = stdenv.lib.licenses.lgpl21;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) libwnck;};
 
   "gi-xlib" = callPackage
···
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "8.20200720.1";
-       sha256 = "0g4wlfkwr9w21hvdywc7sk077rxlnigdr4m4yz41rc0s2nbjc9fn";
+       version = "8.20200810";
+       sha256 = "1wy6ckcf5f6m94gakg1504h1zryail3mmj85sglq03s45vawjcg6";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"
          "-fnetworkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser"
···
      }:
      mkDerivation {
        pname = "git-brunch";
-       version = "1.3.1.0";
-       sha256 = "0k1q3f9hyyagv67mpaj1159vic4kc44nk10nswg0pql38ai5bqvx";
+       version = "1.4.0.0";
+       sha256 = "1dv0hzdfmzm2c3mfmf73lb085279hnfx41ly5393l0vj1v2ln6a4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "github-rest";
-       version = "1.0.2";
-       sha256 = "0q4dxr0080pkszq9vv3j2wx89yhy15jjbk5m7wd1mwirgwxv214m";
-       revision = "2";
-       editedCabalFile = "02brididamvd9g938vqirp6d0vmw7cs9w1yk05ic89kxcl55n8mx";
-       libraryHaskellDepends = [
-         aeson base bytestring http-client http-client-tls http-types jwt
-         mtl scientific text time transformers unliftio unliftio-core
-       ];
-       testHaskellDepends = [
-         aeson aeson-qq base bytestring http-client http-client-tls
-         http-types jwt mtl scientific tasty tasty-golden tasty-hunit
-         tasty-quickcheck text time transformers unliftio unliftio-core
-       ];
-       description = "Query the GitHub REST API programmatically";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "github-rest_1_0_3" = callPackage
-    ({ mkDerivation, aeson, aeson-qq, base, bytestring, http-client
-     , http-client-tls, http-types, jwt, mtl, scientific, tasty
-     , tasty-golden, tasty-hunit, tasty-quickcheck, text, time
-     , transformers, unliftio, unliftio-core
-     }:
-     mkDerivation {
-       pname = "github-rest";
        version = "1.0.3";
        sha256 = "0alwix2lvrvv6ba7nrxg6qvvrdci1vbv94yvq29zmsab9lbv6jrb";
        libraryHaskellDepends = [
···
        ];
        description = "Query the GitHub REST API programmatically";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "github-tools" = callPackage
···
      }:
      mkDerivation {
        pname = "graphviz";
-       version = "2999.20.0.4";
-       sha256 = "047f6sa5rp0f2npgvdrj5irylh0raf01a6nrjj2vsf1mzb1q83xr";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring colour containers directory dlist fgl filepath mtl
-         polyparse process temporary text wl-pprint-text
-       ];
-       testHaskellDepends = [
-         base containers fgl fgl-arbitrary filepath hspec QuickCheck text
-       ];
-       testSystemDepends = [ graphviz ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [ base criterion deepseq text ];
-       description = "Bindings to Graphviz for graph visualisation";
-       license = stdenv.lib.licenses.bsd3;
-     }) {inherit (pkgs) graphviz;};
-
-  "graphviz_2999_20_1_0" = callPackage
-    ({ mkDerivation, base, bytestring, colour, containers, criterion
-     , deepseq, directory, dlist, fgl, fgl-arbitrary, filepath, graphviz
-     , hspec, hspec-discover, mtl, polyparse, process, QuickCheck
-     , temporary, text, wl-pprint-text
-     }:
-     mkDerivation {
-       pname = "graphviz";
        version = "2999.20.1.0";
        sha256 = "0l0zxgb938hh09qirggbaskq79mgj3s081cnr42y5vm1rp1jir2s";
        isLibrary = true;
···
        benchmarkHaskellDepends = [ base criterion deepseq text ];
        description = "Bindings to Graphviz for graph visualisation";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {inherit (pkgs) graphviz;};
 
   "graql" = callPackage
···
        ];
        description = "A standalone StatusNotifierItem/AppIndicator tray";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gtk3;};
 
   "gtk-strut" = callPackage
···
        libraryHaskellDepends = [ base gi-gdk gi-gtk text transformers ];
        description = "Libary for creating strut windows with gi-gtk";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gtk-toggle-button-list" = callPackage
···
        broken = true;
      }) {};
 
+  "hapistrano_0_4_1_2" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, async, base, directory
+     , filepath, formatting, gitrev, hspec, hspec-discover, mtl
+     , optparse-applicative, path, path-io, process, QuickCheck
+     , silently, stm, temporary, time, transformers, typed-process, yaml
+     }:
+     mkDerivation {
+       pname = "hapistrano";
+       version = "0.4.1.2";
+       sha256 = "0ylahq6hnyzyhh4fb2d21fwisq8a8x5rij6zrzvhcapnir2vkrn0";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson ansi-terminal base filepath formatting gitrev mtl path
+         process stm time transformers typed-process yaml
+       ];
+       executableHaskellDepends = [
+         aeson async base formatting gitrev optparse-applicative path
+         path-io stm yaml
+       ];
+       testHaskellDepends = [
+         base directory filepath hspec mtl path path-io process QuickCheck
+         silently temporary yaml
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A deployment library for Haskell applications";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "happindicator" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, glib, gtk
      , gtk2hs-buildtools, libappindicator-gtk2, mtl
···
      }:
      mkDerivation {
        pname = "haskell-ci";
-       version = "0.10.2";
-       sha256 = "07yqgwacz1qll2nvwdq1w4n35yca1k569i947s310pb22asbd5w2";
+       version = "0.10.3";
+       sha256 = "18qynghm1aj0qr18v6m3md75p2l3kyhki03798jwhi4kc5qdk2vv";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.lgpl21;
      }) {inherit (pkgs) glib; inherit (pkgs) gobject-introspection;};
 
-  "haskell-gi_0_24_3" = callPackage
+  "haskell-gi_0_24_4" = callPackage
     ({ mkDerivation, ansi-terminal, attoparsec, base, bytestring, Cabal
      , cabal-doctest, containers, directory, doctest, filepath, glib
      , gobject-introspection, haskell-gi-base, mtl, pretty-show, process
···
      }:
      mkDerivation {
        pname = "haskell-gi";
-       version = "0.24.3";
-       sha256 = "1bzbb0hbk0hz265rbh4dsypwiqxcjn0gy0sql287bm57rj0mvnn0";
+       version = "0.24.4";
+       sha256 = "0q2r8y9ca3w389sx613jz95hg9cssj6g4i2xyi8423nyqvyzms48";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          ansi-terminal attoparsec base bytestring Cabal containers directory
···
        broken = true;
      }) {};
 
+  "hasql-optparse-applicative_0_3_0_6" = callPackage
+    ({ mkDerivation, base-prelude, hasql, hasql-pool
+     , optparse-applicative
+     }:
+     mkDerivation {
+       pname = "hasql-optparse-applicative";
+       version = "0.3.0.6";
+       sha256 = "16k6k2qp8avnlsidyjk458lags2633789wvvwdy4xgmiqs1riqr9";
+       libraryHaskellDepends = [
+         base-prelude hasql hasql-pool optparse-applicative
+       ];
+       description = "\"optparse-applicative\" parsers for \"hasql\"";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "hasql-pool" = callPackage
     ({ mkDerivation, base-prelude, hasql, hspec, resource-pool, time }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "hedis";
-       version = "0.12.13";
-       sha256 = "1axsv81r1q393m178x89km49pi7w7dci0l48cnjdskdz99jwvywq";
+       version = "0.12.14";
+       sha256 = "14qd248ccijakksbaj72nwz8dx8qg4bifla3p0vsm6v96xb2qjbw";
        libraryHaskellDepends = [
          async base bytestring bytestring-lexing deepseq errors exceptions
          HTTP mtl network network-uri resource-pool scanner stm text time
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "hie-bios_0_6_1" = callPackage
+  "hie-bios_0_6_2" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, bytestring
      , conduit, conduit-extra, containers, cryptohash-sha1, deepseq
      , directory, extra, file-embed, filepath, ghc, hslogger
···
      }:
      mkDerivation {
        pname = "hie-bios";
-       version = "0.6.1";
-       sha256 = "0lvsfhv2ahzzqh9jv7837akcy5c4mnyfwrb5k2jlkpq3ywr13x8c";
+       version = "0.6.2";
+       sha256 = "0x0lgrkbp4f9r96cf65d8qg55hp2qb14xd3zzap5yhybhlp54w8m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hpc-lcov";
        version = "1.0.1";
        sha256 = "01ws5y2vavgm7151dcabw3jwny1prrnzn5b04q76m5gc6a36wivl";
+       revision = "1";
+       editedCabalFile = "1jv81ywwzvr37zki8hjylj6gfhamq7fi7rpjyk1g0d06ac9ix0zp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers hpc ];
···
      , text, time, unordered-containers, uuid, vector
 
      , text, time, unordered-containers, uuid, vector
-     , text, time, unordered-containers, uuid, vector
-     mkDerivation {
-     , text, time, unordered-containers, uuid, vector
-       version = "0.1.6.0";
-     , text, time, unordered-containers, uuid, vector
-       revision = "1";
-     , text, time, unordered-containers, uuid, vector
-     , text, time, unordered-containers, uuid, vector
-     , text, time, unordered-containers, uuid, vector
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-     , text, time, unordered-containers, uuid, vector
      , text, time, unordered-containers, uuid, vector
      mkDerivation {
      , text, time, unordered-containers, uuid, vector
···
      , text, time, unordered-containers, uuid, vector
      , text, time, unordered-containers, uuid, vector
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
      , text, time, unordered-containers, uuid, vector
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "hspec_2_7_2" = callPackage
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+     }:
+     mkDerivation {
+     , text, time, unordered-containers, uuid, vector
+       version = "2.7.2";
+       sha256 = "0zb9b85vx7wyx8zcrkqwlwp9qmsg3f5qnd43ps6xfrsn1l2vszm9";
+       libraryHaskellDepends = [
+     , text, time, unordered-containers, uuid, vector
+       ];
+     , text, time, unordered-containers, uuid, vector
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
      , text, time, unordered-containers, uuid, vector
      , text, time, unordered-containers, uuid, vector
      , text, time, unordered-containers, uuid, vector
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "hspec-core_2_7_2" = callPackage
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+     }:
+     mkDerivation {
+     , text, time, unordered-containers, uuid, vector
+       version = "2.7.2";
+       sha256 = "0vzsxwgg3rfp6mxq85sb1v2wd77f2lwdg9zm5f1mqm02avfglfnk";
+       libraryHaskellDepends = [
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+       ];
+       testHaskellDepends = [
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+         transformers
+       ];
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
      , text, time, unordered-containers, uuid, vector
      , text, time, unordered-containers, uuid, vector
      , text, time, unordered-containers, uuid, vector
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "hspec-discover_2_7_2" = callPackage
+     , text, time, unordered-containers, uuid, vector
+     }:
+     mkDerivation {
+     , text, time, unordered-containers, uuid, vector
+       version = "2.7.2";
+       sha256 = "0n3lvdznmrgrhd11969xn4ci31439y6fpr9xkzsabij87rw091l8";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base directory filepath ];
+       executableHaskellDepends = [ base directory filepath ];
+       testHaskellDepends = [
+     , text, time, unordered-containers, uuid, vector
+       ];
+     , text, time, unordered-containers, uuid, vector
+     , text, time, unordered-containers, uuid, vector
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
      , text, time, unordered-containers, uuid, vector
      , text, time, unordered-containers, uuid, vector
      mkDerivation {
···
      }:
      mkDerivation {
      , text, time, unordered-containers, uuid, vector
-       version = "0.1.0.2";
-     , text, time, unordered-containers, uuid, vector
-       isLibrary = true;
-       isExecutable = true;
-     , text, time, unordered-containers, uuid, vector
-     , text, time, unordered-containers, uuid, vector
-     , text, time, unordered-containers, uuid, vector
-     , text, time, unordered-containers, uuid, vector
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-     , text, time, unordered-containers, uuid, vector
-     , text, time, unordered-containers, uuid, vector
-     , text, time, unordered-containers, uuid, vector
-     }:
-     mkDerivation {
-     , text, time, unordered-containers, uuid, vector
        version = "0.1.0.3";
      , text, time, unordered-containers, uuid, vector
        isLibrary = true;
···
      , text, time, unordered-containers, uuid, vector
      , text, time, unordered-containers, uuid, vector
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
      , text, time, unordered-containers, uuid, vector
···
        ];
        description = "Inline some Assembly in ur Haskell!";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "inline-c_0_5_6_1" = callPackage
···
        broken = true;
      }) {};
 
+  "interval-algebra" = callPackage
+    ({ mkDerivation, base, hspec, QuickCheck, time }:
+     mkDerivation {
+       pname = "interval-algebra";
+       version = "0.1.2";
+       sha256 = "1nhpcrp7r6ba9mqwrfkx0zk7awdw24kh75ggq1wcif6mpir2khkx";
+       libraryHaskellDepends = [ base time ];
+       testHaskellDepends = [ base hspec QuickCheck time ];
+       description = "An implementation of Allen's interval algebra for temporal logic";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "interval-functor" = callPackage
     ({ mkDerivation, base, hedgehog, transformers }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "invertible";
-       version = "0.2.0.6";
-       sha256 = "1z53i81i8w3hxq0869l2i74s7k6sizbc3i4z0j5s7m412i119amd";
+       version = "0.2.0.7";
+       sha256 = "1ngcmy59cyrg5idcn8a4gxg6ipq88rhhwhdb09gra8jcraq9n7ii";
        libraryHaskellDepends = [
          base haskell-src-meta invariant lens partial-isomorphisms
          semigroupoids template-haskell transformers
···
      }:
      mkDerivation {
        pname = "invertible-grammar";
-       version = "0.1.2";
-       sha256 = "1nf7dchcxs8wwd2hgfpf04qd63ws22pafjwb5911lq7da8k1y57j";
-       revision = "4";
-       editedCabalFile = "1574py7cbgig031kh2v52m0w2af0sr0lyaj20makwrm9g8g6k9k8";
+       version = "0.1.3";
+       sha256 = "160hw7p5mpajwmv8fps2gicqj3x3yr9w239pfnv9i5gsf4irnn9n";
        libraryHaskellDepends = [
          base bifunctors containers mtl prettyprinter profunctors semigroups
          tagged template-haskell text transformers
        ];
        description = "Invertible parsing combinators framework";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "invertible-hlist" = callPackage
···
     ({ mkDerivation, base, binary, bytestring, iproute }:
      mkDerivation {
        pname = "ip2proxy";
-       version = "2.2.1";
-       sha256 = "08ywvg39n59i8p66fpapcpj722lkam7pyd38525p3w4z735d8842";
+       version = "3.0.0";
+       sha256 = "1hi1q0kiqqp96w29y9699s66rmyr7k0fp6s7z86ll9n3bmf0a4g4";
        libraryHaskellDepends = [ base binary bytestring iproute ];
        description = "IP2Proxy Haskell package for proxy detection";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "ipfs";
-       version = "1.1.0";
-       sha256 = "0qya888h0bf1d1mah3vn5kidv89j5lh0fra9r3i4x0837y7bh5bv";
+       version = "1.1.2";
+       sha256 = "13pzj9wx7f0wgzk1hy791a4p2ivfxyb045srfa75l065ca8bjnis";
        libraryHaskellDepends = [
          aeson base bytestring envy flow Glob ip lens monad-logger
          regex-compat rio servant-client servant-server swagger2 text vector
···
      }:
      mkDerivation {
        pname = "ixset-typed-conversions";
-       version = "0.1.0.0";
-       sha256 = "1ls2hd748pacrdr5w5w3dl9byxas8rhn52rhrs3937l6czmynji0";
+       version = "0.1.0.1";
+       sha256 = "09fl92lkalbzq23742wjiw4568607cdbxy3a8qgkm2hn8r7djhwi";
        libraryHaskellDepends = [
          base exceptions hashable ixset-typed unordered-containers
          zipper-extra
···
      }:
      mkDerivation {
        pname = "jukebox";
-       version = "0.5.1";
-       sha256 = "0f74mml9qpxlfxxvldz9qz89bscj7qwmc5gb42rgfgbkfin6zrdk";
+       version = "0.5.2";
+       sha256 = "1nhz7rf8sczrhph0h9hia1vqxig1bcpc8v6zvxgrywmacl1mnky6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "keera-hails-i18n";
-       version = "0.6.0";
-       sha256 = "0xal6xq60yljn53qrxcgsm4jc630za8jfcqxxvlrr9g53kganmpc";
+       version = "0.7.0";
+       sha256 = "0k5cvnkc5r99r4361hn5jrmslvb21y3k2pj0dryiwbs21jwyv213";
        libraryHaskellDepends = [
          base directory filepath glib hgettext MissingK setlocale
          utf8-string
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "keera-hails-mvc-controller";
-       version = "0.6.0";
-       sha256 = "0k1i443mmw2lrpsrh8dzfzcydfzs305b4np45bfc0hlb6czkc4p6";
+       version = "0.7.0";
+       sha256 = "1j7vhkghdh4hrap7g2xshpd2fw3acgwvi68f2c01mqmfi5dl4z2n";
        libraryHaskellDepends = [ base ];
        description = "Haskell on Gtk rails - Gtk-based controller for MVC applications";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "keera-hails-mvc-environment-gtk";
-       version = "0.6.0";
-       sha256 = "0acrafqcjq01qbd68c8ch510ggz3x581jrfx411xh8y0ngk3ydjv";
+       version = "0.7.0";
+       sha256 = "0px1f9jpdgkd253bhgalxk5rxx971s0s2a845h81x6hy9wi7n6mf";
        libraryHaskellDepends = [
          base keera-hails-mvc-model-protectedmodel keera-hails-mvc-view
          keera-hails-mvc-view-gtk
···
      }:
      mkDerivation {
        pname = "keera-hails-mvc-model-lightmodel";
-       version = "0.6.0";
-       sha256 = "0m2v5dsvjrx42m5psb2yw9jgwzn14yw4l3yswpm469wfdyli88n4";
+       version = "0.7.0";
+       sha256 = "0nklcgsadm2h62jwp8i419dwrsfs885cmglr5n39b7r1zy7dsa0f";
        libraryHaskellDepends = [
          base containers keera-hails-reactivevalues MissingK stm
          template-haskell
···
      }:
      mkDerivation {
        pname = "keera-hails-mvc-model-protectedmodel";
-       version = "0.6.0";
-       sha256 = "19lb7yxfgrv074z0qcdqa7fdpjx1mgl1djcl6vaz8ydf69qqdyfn";
+       version = "0.7.0";
+       sha256 = "0vz4bcnm2p03c3x6qspii9kylcv4d0qlmzawm6x1f148srrwidi7";
        libraryHaskellDepends = [
          base containers keera-hails-reactivevalues MissingK stm
          template-haskell
···
      }:
      mkDerivation {
        pname = "keera-hails-reactive-cbmvar";
-       version = "0.6.0";
-       sha256 = "0g9fb8h1japh0hp6bn02lcsm5cls1lk4hhyk7rbxfkrfiln1khqi";
+       version = "0.7.0";
+       sha256 = "085zli0s7p8f2ib2882q4qpqlh6czw62626fnrjiks4sff3f31c7";
        libraryHaskellDepends = [
          base keera-callbacks keera-hails-reactivevalues lens
        ];
···
      }:
      mkDerivation {
        pname = "keera-hails-reactive-gtk";
-       version = "0.6.0";
-       sha256 = "1vr0dy8a44fdh4ilwgzm8g5vjdcq9ll145v47ghpn7z7dhlmbgki";
+       version = "0.7.0";
+       sha256 = "1xn5ar20x8kpiv1z6i5gcvm09xjgrdppjyxd2si8nyv7gw173scr";
        libraryHaskellDepends = [
          base bytestring cairo glib gtk gtk-helpers
          keera-hails-reactivevalues mtl transformers
···
      }:
      mkDerivation {
        pname = "keera-hails-reactive-htmldom";
-       version = "0.6.0";
-       sha256 = "1hpkmxdhvvwjly860n4kk4ghw47a0yc92dn1ajkz0fc849zp2mpa";
+       version = "0.7.0";
+       sha256 = "05lz38pffm6k3kbw3g6gkslixq4nc764n1i4dxz9p6zwj27f6svc";
        libraryHaskellDepends = [
          base ghcjs-dom keera-callbacks keera-hails-reactive-cbmvar
          keera-hails-reactivevalues mtl transformers
···
      }:
      mkDerivation {
        pname = "keera-hails-reactive-network";
-       version = "0.6.0";
-       sha256 = "0k0qfh10wv4rabvi2zgwsv97mz7nbvg3rvxfddh6i2hsa48cjvcf";
+       version = "0.7.0";
+       sha256 = "0qn1vz55fpvrx4l3lak0lkx0ggli8smf3r4za3zypgfv3a1q3rxm";
        libraryHaskellDepends = [
          base bytestring keera-hails-reactivevalues network network-bsd
        ];
···
     ({ mkDerivation, base, keera-hails-reactivevalues, wx, wxcore }:
      mkDerivation {
        pname = "keera-hails-reactive-wx";
-       version = "0.6.0";
-       sha256 = "1yspys7vqg3xm86j4k0wcih5f9iqi0n7f6vnc83gjl84c8w8zac1";
+       version = "0.7.0";
+       sha256 = "1cpwyqqcdnxc30qmny0rq0ww51vv8g241jwjis1sbs47hvwgvi27";
        libraryHaskellDepends = [
          base keera-hails-reactivevalues wx wxcore
        ];
···
      }:
      mkDerivation {
        pname = "keera-hails-reactive-yampa";
-       version = "0.6.0";
-       sha256 = "19zxpl9wypy31nwn2ghjcbkvn5xwqfpp9rprkx5ilax3rjagcqcc";
+       version = "0.7.0";
+       sha256 = "178r5igwnvkbpz1hypiy4l61s3amr4j8bk1yvqc7jvs40cldiw1x";
        libraryHaskellDepends = [
          base keera-callbacks keera-hails-reactivevalues time Yampa
        ];
···
      }:
      mkDerivation {
        pname = "keera-hails-reactivevalues";
-       version = "0.6.0";
-       sha256 = "1fji0axzj0558dczvzgkwpxnkszfdk3zgky933pdkpcq1cnjz0d3";
+       version = "0.7.0";
+       sha256 = "1dmsjyvrzh8rdp9kcc8ysar0zw9gaxqh231xaqy17ndfhlmp2nzq";
        libraryHaskellDepends = [ base contravariant ];
        testHaskellDepends = [
          base directory filepath hlint HUnit mtl process QuickCheck
···
      }:
      mkDerivation {
        pname = "kontrakcja-templates";
-       version = "0.11";
-       sha256 = "09fivafr368kfj5pp0g9r13jvrihhcwhx9ay2f45qilcpv4qbb1r";
+       version = "0.12";
+       sha256 = "1asmsk3d4wqmiqsxnhaknmnrplrwq6cx6p7n7859rl6x7ac0fjg0";
        libraryHaskellDepends = [
          base containers directory exceptions HStringTemplate html json
          monad-control mtl time transformers transformers-base
···
        ];
        description = "Create Kubernetes Admission Webhooks in Haskell";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "kubernetes-webhook-haskell_0_2_0_3" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring
+     , text, unordered-containers
+     }:
+     mkDerivation {
+       pname = "kubernetes-webhook-haskell";
+       version = "0.2.0.3";
+       sha256 = "1xvc35jibs2nizzp6xgdzzyx6fhgzgqb55a48vl1djbi84s8b4q1";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring binary bytestring text
+         unordered-containers
+       ];
+       description = "Create Kubernetes Admission Webhooks in Haskell";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "kuifje" = callPackage
···
      }:
      mkDerivation {
        pname = "language-ats";
-       version = "1.7.10.1";
-       sha256 = "19m9qalh9xiaw6n60zbhs8yqhd0acq08bkx42i44vfmm0917jys3";
-       revision = "1";
-       editedCabalFile = "1g1dqii5hrr016g1n8sjz7qyzrnmy46zsfd9cp7hmkxqgjk35p8k";
+       version = "1.7.10.2";
+       sha256 = "10lanbzbaywyc3a8lq2ndgmpqq2kgpm4vkjxw7gl4irzjn3206yg";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          ansi-wl-pprint array base composition-prelude containers deepseq
···
      }:
      mkDerivation {
        pname = "language-dickinson";
-       version = "1.1.0.2";
-       sha256 = "1g2d32535vmgjiy1ld4hq8g5il98c3h6ykfdl34fq8329qf9gxxr";
+       version = "1.1.0.3";
+       sha256 = "1dfm89zrmq2ibyhjn4hbzq6yfm5acc63s47w7bp1asn6lxnd9dc0";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "Massiv (Массив) is an Array Library";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "massiv-io" = callPackage
···
        ];
        description = "Import/export of Image files into massiv Arrays";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "massiv-io_0_3_0_1" = callPackage
···
        description = "Import/export of Image files into massiv Arrays";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "massiv-scheduler" = callPackage
···
        ];
        description = "Library that contains generators, properties and tests for Massiv Array Library";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "master-plan" = callPackage
···
        ];
        description = "Collection of tools for numeric computations";
        license = stdenv.lib.licenses.bsd2;
+     }) {};
+
+  "math-functions_0_3_4_1" = callPackage
+    ({ mkDerivation, base, data-default-class, deepseq, erf, gauge
+     , primitive, QuickCheck, random, tasty, tasty-hunit
+     , tasty-quickcheck, vector, vector-th-unbox
+     }:
+     mkDerivation {
+       pname = "math-functions";
+       version = "0.3.4.1";
+       sha256 = "13x4whrnacqvmprfi665n5nby8hqlz1pxrglsl81chyk0gy0l2p2";
+       libraryHaskellDepends = [
+         base data-default-class deepseq primitive vector
+       ];
+       testHaskellDepends = [
+         base data-default-class deepseq erf primitive QuickCheck tasty
+         tasty-hunit tasty-quickcheck vector vector-th-unbox
+       ];
+       benchmarkHaskellDepends = [
+         base data-default-class gauge random vector
+       ];
+       description = "Collection of tools for numeric computations";
+       license = stdenv.lib.licenses.bsd2;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "math-grads" = callPackage
···
      }:
      mkDerivation {
        pname = "matrix-as-xyz";
-       version = "0.1.1.3";
-       sha256 = "1wrc9605w3wswx14dx8qfsc5a5pyg0mh2f7bkr6hca2a8c59dlym";
+       version = "0.1.2.2";
+       sha256 = "1qblzv6893z6y9jkp2v71g73x35bbizxghliby39fx6kxw6l2j7w";
+       revision = "2";
+       editedCabalFile = "01r2n4ys2z92wkdpky171dbxklynvp5cjf7vi61sf4hjdqih17nf";
        libraryHaskellDepends = [ base matrix parsec ];
-       testHaskellDepends = [
-         base doctest hspec matrix parsec QuickCheck
-       ];
-       description = "Read and Display representation of matrix like \"x,y,z\"";
-       license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "matrix-as-xyz_0_1_2_1" = callPackage
-    ({ mkDerivation, base, doctest, hspec, matrix, parsec, QuickCheck
-     }:
-     mkDerivation {
-       pname = "matrix-as-xyz";
-       version = "0.1.2.1";
-       sha256 = "0k49k16mxp7izkanan0yrrlkzvblw1w7bvfrh486fys83gvkb3x8";
-       libraryHaskellDepends = [ base doctest hspec matrix parsec ];
        testHaskellDepends = [
          base doctest hspec matrix parsec QuickCheck
        ];
···
      }:
      mkDerivation {
        pname = "matterhorn";
-       version = "50200.9.0";
-       sha256 = "1ky022msmh1ashhw8kwxwj4lcswa6xin2537q4bx8miii07cfvaw";
+       version = "50200.10.0";
+       sha256 = "0wj1bsqmlzb7q92h3hj5gwgwknwqh5p487mgbcd82rgflp4sq5rx";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "Terminal client for the Mattermost chat system";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
+       maintainers = with stdenv.lib.maintainers; [ kiwi ];
      }) {};
 
   "mattermost-api" = callPackage
···
      }:
      mkDerivation {
        pname = "mattermost-api";
-       version = "50200.6.0";
-       sha256 = "0p03r9hss1xrg4a542l2pyacm49ahkkqkr3afcwgdyb0m65ra620";
+       version = "50200.7.0";
+       sha256 = "1zqvfp0miql9ha9fcvr84p7yhli5br9kmsn080h058zknyabrl8p";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "mattermost-api-qc";
-       version = "50200.6.0";
-       sha256 = "11j1bli553n59j54qn9ka1a5d37jk1ijgbwaa3001gmxhj526r62";
+       version = "50200.7.0";
+       sha256 = "0gzrbgzynzr5g234dm1qbs9xkddfvm08rv1n12qx0191fzicbf25";
        libraryHaskellDepends = [
          base containers mattermost-api QuickCheck text time
        ];
···
        broken = true;
      }) {};
 
+  "metro" = callPackage
+    ({ mkDerivation, base, binary, bytestring, hashable, hslogger, mtl
+     , transformers, unix-time, unliftio, unordered-containers
+     }:
+     mkDerivation {
+       pname = "metro";
+       version = "0.1.0.1";
+       sha256 = "1snivs6zf3pjkh6p29wafjnrw8sfcrakl5s8ksn20hr1y8780v9k";
+       libraryHaskellDepends = [
+         base binary bytestring hashable hslogger mtl transformers unix-time
+         unliftio unordered-containers
+       ];
+       description = "A simple tcp and udp socket server framework";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "metro-socket" = callPackage
+    ({ mkDerivation, base, bytestring, directory, hashable, hslogger
+     , metro, mtl, network, transformers, unliftio
+     }:
+     mkDerivation {
+       pname = "metro-socket";
+       version = "0.1.0.0";
+       sha256 = "0ph2w4dwkixg5w3m13giy75zcl1f1kd52lrkbx6v0vf595dhgrcf";
+       libraryHaskellDepends = [
+         base bytestring directory hashable hslogger metro mtl network
+         transformers unliftio
+       ];
+       description = "Socket transport for metro";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "metro-transport-crypto" = callPackage
+    ({ mkDerivation, base, binary, bytestring, cryptonite, metro
+     , QuickCheck, quickcheck-instances, text, unliftio
+     }:
+     mkDerivation {
+       pname = "metro-transport-crypto";
+       version = "0.1.0.0";
+       sha256 = "1w7h47lrmw1zzdi8bp5rxrxidpxl1pf9q7ns38mqwf49xl9yyvz7";
+       libraryHaskellDepends = [
+         base binary bytestring cryptonite metro text unliftio
+       ];
+       testHaskellDepends = [
+         base bytestring cryptonite metro QuickCheck quickcheck-instances
+       ];
+       description = "Crypto transport for metro";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "metro-transport-tls" = callPackage
+    ({ mkDerivation, base, bytestring, data-default-class, metro, pem
+     , tls, x509, x509-store, x509-validation
+     }:
+     mkDerivation {
+       pname = "metro-transport-tls";
+       version = "0.1.0.0";
+       sha256 = "1lsw4s7h4s1m2hm5bwhq2nx0acnaw1377ifdf0xphb1rzgbdacvb";
+       libraryHaskellDepends = [
+         base bytestring data-default-class metro pem tls x509 x509-store
+         x509-validation
+       ];
+       description = "TLS transport for metro";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "metro-transport-websockets" = callPackage
+    ({ mkDerivation, base, bytestring, metro, websockets }:
+     mkDerivation {
+       pname = "metro-transport-websockets";
+       version = "0.1.0.0";
+       sha256 = "1jyy3sssz8ixwqdlf8zph05pfrm6qnf56sjsq8bx6yah9psy92dg";
+       libraryHaskellDepends = [ base bytestring metro websockets ];
+       description = "Websockets transport for metro";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "metro-transport-xor" = callPackage
+    ({ mkDerivation, base, bytestring, metro, unliftio }:
+     mkDerivation {
+       pname = "metro-transport-xor";
+       version = "0.1.0.0";
+       sha256 = "1hx839sxd2lrx6vsxswi4i88x1d1489jcdmh2vbnc2dvnssnqcpv";
+       libraryHaskellDepends = [ base bytestring metro unliftio ];
+       description = "XOR transport for metro";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "metronome" = callPackage
     ({ mkDerivation, base, data-lens, data-lens-template, hosc, stm }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "mixed-types-num";
-       version = "0.4.0.1";
-       sha256 = "10fkqb4d534nr5yqdybmvrbg3alfjvki4qxg20ma8mwxyiz4wc5g";
-       libraryHaskellDepends = [
-         base hspec hspec-smallcheck mtl QuickCheck smallcheck
-         template-haskell
-       ];
-       testHaskellDepends = [ base hspec hspec-smallcheck QuickCheck ];
-       description = "Alternative Prelude with numeric and logic expressions typed bottom-up";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "mixed-types-num_0_4_0_2" = callPackage
-    ({ mkDerivation, base, hspec, hspec-smallcheck, mtl, QuickCheck
-     , smallcheck, template-haskell
-     }:
-     mkDerivation {
-       pname = "mixed-types-num";
        version = "0.4.0.2";
        sha256 = "0kirxpnmwwnbxamwpzrxyx69n482xhifqpr5id73pfni7lrd126p";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base hspec hspec-smallcheck QuickCheck ];
        description = "Alternative Prelude with numeric and logic expressions typed bottom-up";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "mixpanel-client" = callPackage
···
        broken = true;
      }) {};
 
+  "monad-introspect" = callPackage
+    ({ mkDerivation, base, coercion-extras, mmorph, mtl, transformers
+     }:
+     mkDerivation {
+       pname = "monad-introspect";
+       version = "0.1.0.0";
+       sha256 = "15c5ind2ddmj7xqps5fvlwl9awvsrpqcwaszlikf697aqjqra1nb";
+       libraryHaskellDepends = [
+         base coercion-extras mmorph mtl transformers
+       ];
+       description = "A reader monad that gives the environment access to the entire transformer stack";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "monad-io-adapter" = callPackage
     ({ mkDerivation, base, exceptions, hspec, monad-control
      , monad-logger, mtl, transformers, transformers-base
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "monad-logger_0_3_35" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, conduit-extra
+     , exceptions, fast-logger, lifted-base, monad-control, monad-loops
+     , mtl, resourcet, stm, stm-chans, template-haskell, text
+     , transformers, transformers-base, transformers-compat
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "monad-logger";
+       version = "0.3.35";
+       sha256 = "1mrwwv3h3wy84kgphwn6ahjzxab0bzgzzbqla1c3jx02xl9x3q72";
+       libraryHaskellDepends = [
+         base bytestring conduit conduit-extra exceptions fast-logger
+         lifted-base monad-control monad-loops mtl resourcet stm stm-chans
+         template-haskell text transformers transformers-base
+         transformers-compat unliftio-core
+       ];
+       description = "A class of monads which can log messages";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "monad-logger-json" = callPackage
     ({ mkDerivation, aeson, base, monad-logger, template-haskell, text
      }:
···
        pname = "monad-logger-syslog";
        version = "0.1.6.0";
        sha256 = "1n4r0fl043r18683ym3k03sdm3b9wlxfzjgmnxi804kwna639rj3";
+       revision = "1";
+       editedCabalFile = "0177m5h891s49yv924c5yqbfninc6x298vbpmx3fri6cychamgbl";
        libraryHaskellDepends = [
          base bytestring fast-logger hsyslog monad-logger text transformers
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "mwc-random_0_15_0_0" = callPackage
+  "mwc-random_0_15_0_1" = callPackage
     ({ mkDerivation, base, bytestring, doctest, gauge, math-functions
      , mersenne-random, primitive, QuickCheck, random, tasty
      , tasty-hunit, tasty-quickcheck, time, vector
      }:
      mkDerivation {
        pname = "mwc-random";
-       version = "0.15.0.0";
-       sha256 = "1hyqyakm9kbrbgr247n72rp90hcrwhak2p90bldkd2himmfaskxk";
+       version = "0.15.0.1";
+       sha256 = "1p8c5g4hb72k90ai39rgpn6cr942i6636l1y0zfp9xgjb3v0a2q3";
        libraryHaskellDepends = [
          base math-functions primitive random time vector
        ];
···
      }) {};
 
   "myxine-client" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, dependent-map
-     , dependent-sum, file-embed, hashable, http-client, http-types, req
-     , template-haskell, text, transformers, unordered-containers
+    ({ mkDerivation, aeson, async, base, blaze-html, blaze-markup
+     , bytestring, constraints, containers, dependent-map, file-embed
+     , hashable, http-client, http-types, lens, modern-uri, mtl, req
+     , salve, some, spoon, template-haskell, text, transformers
+     , unordered-containers
      }:
      mkDerivation {
        pname = "myxine-client";
-       version = "0.0.0.2";
-       sha256 = "1pfvkdc7pa7x16skdcx355l20qk6574nhkjyzpk9jb7i0wqjqsf8";
+       version = "0.0.1.0";
+       sha256 = "1vd1dxg39vwz9w58zxpp3mk66gk00534h6c846v2d77nqn0yajf0";
        libraryHaskellDepends = [
-         aeson base bytestring dependent-map dependent-sum file-embed
-         hashable http-client http-types req template-haskell text
+         aeson async base blaze-html blaze-markup bytestring constraints
+         containers dependent-map file-embed hashable http-client http-types
+         lens modern-uri mtl req salve some spoon template-haskell text
          transformers unordered-containers
        ];
        testHaskellDepends = [ bytestring text ];
···
      }:
      mkDerivation {
        pname = "ngx-export-tools-extra";
-       version = "0.5.5.0";
-       sha256 = "1w7vm0sic1v4zy10m8rkzrgbkvn3wnb4320gkl2dclsfdk70d5b3";
+       version = "0.5.5.1";
+       sha256 = "0x3c1r0ddbk740182gwv43s2zxr6aj9k6y4npv7vi0fwyxjcqgkj";
        libraryHaskellDepends = [
          aeson ansi-wl-pprint array base base64 binary bytestring
          case-insensitive containers ede enclosed-exceptions http-client
···
      }:
      mkDerivation {
        pname = "niv";
-       version = "0.2.14";
-       sha256 = "10iyddplwwfbvj8m3fv0kzjbjnv8yhp17b3xi23dv5pyxzmacp6l";
+       version = "0.2.16";
+       sha256 = "0z2wws28nl7xd5fbc5za287y8ryvfrgha4qh7aahr3x1j9sywpyg";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "nom";
-       version = "0.1.0.1";
-       sha256 = "01dg6h98pdzhrwryzhcmjrynxv6674pjpklkxkrpaymy29a9c9a0";
+       version = "0.1.0.2";
+       sha256 = "18vgasg9szc88pa61gw6qpasx6l9jx0z9lm36xa96j4ml4vr3ddf";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          algebra base containers data-default extra finite-typelits flow
···
      }) {};
 
   "nonempty-containers" = callPackage
-    ({ mkDerivation, base, comonad, containers, deepseq, hedgehog
-     , hedgehog-fn, nonempty-vector, semigroupoids, tasty
-     , tasty-hedgehog, text, these, vector
-     }:
-     mkDerivation {
-       pname = "nonempty-containers";
-       version = "0.3.3.0";
-       sha256 = "11mrv2vzdqxjx3xn93zlwfxh7z2d5ca5cbsr25y4zv34brn114g2";
-       libraryHaskellDepends = [
-         base comonad containers deepseq nonempty-vector semigroupoids these
-         vector
-       ];
-       testHaskellDepends = [
-         base comonad containers hedgehog hedgehog-fn nonempty-vector
-         semigroupoids tasty tasty-hedgehog text these vector
-       ];
-       description = "Non-empty variants of containers data types, with full API";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "nonempty-containers_0_3_4_0" = callPackage
     ({ mkDerivation, aeson, base, comonad, containers, deepseq
      , hedgehog, hedgehog-fn, nonempty-vector, semigroupoids, tasty
      , tasty-hedgehog, text, these, vector
···
        ];
        description = "Non-empty variants of containers data types, with full API";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "nonempty-lift" = callPackage
···
        broken = true;
      }) {};
 
+  "om-http-logging" = callPackage
+    ({ mkDerivation, base, http-types, monad-logger, safe-exceptions
+     , uuid, wai
+     }:
+     mkDerivation {
+       pname = "om-http-logging";
+       version = "0.1.0.0";
+       sha256 = "16swgkk6w7sxnbfdz07vz3pkqjcpq27g1hswqvdxfq5gfq5kgp67";
+       libraryHaskellDepends = [
+         base http-types monad-logger safe-exceptions uuid wai
+       ];
+       description = "om-http-logging";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "omaketex" = callPackage
     ({ mkDerivation, base, optparse-applicative, shakespeare-text
      , shelly, text
···
      }:
      mkDerivation {
        pname = "opaleye";
-       version = "0.6.7004.2";
-       sha256 = "0lmfpbrfy6l7nlkjn26smmv3n992b54xnplwm67jjpryaz7psdz1";
-       revision = "1";
-       editedCabalFile = "1gnig6gdpcz6zkzp9x97m9blhgha2z4ksd9pyqpvm6qrdsjpqsfp";
-       libraryHaskellDepends = [
-         aeson base base16-bytestring bytestring case-insensitive
-         contravariant postgresql-simple pretty product-profunctors
-         profunctors scientific semigroups text time time-locale-compat
-         transformers uuid void
-       ];
-       testHaskellDepends = [
-         aeson base containers contravariant dotenv hspec hspec-discover
-         multiset postgresql-simple product-profunctors profunctors
-         QuickCheck semigroups text time transformers uuid
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "An SQL-generating DSL targeting PostgreSQL";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "opaleye_0_6_7005_0" = callPackage
-    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
-     , case-insensitive, containers, contravariant, dotenv, hspec
-     , hspec-discover, multiset, postgresql-simple, pretty
-     , product-profunctors, profunctors, QuickCheck, scientific
-     , semigroups, text, time, time-locale-compat, transformers, uuid
-     , void
-     }:
-     mkDerivation {
-       pname = "opaleye";
        version = "0.6.7005.0";
        sha256 = "0i5lwfvj7382ayxzdbip1nwjiiy7jn58g7qa33s44x3pnjv3wssy";
        revision = "1";
···
        testToolDepends = [ hspec-discover ];
        description = "An SQL-generating DSL targeting PostgreSQL";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "opaleye-classy" = callPackage
···
      }:
      mkDerivation {
        pname = "optima";
-       version = "0.4";
-       sha256 = "0ryrz9739g1zql9ldll2ilfiyazgz5xixk31wajdqz0xdzqg3bbl";
+       version = "0.4.0.1";
+       sha256 = "029bizcajhmvkgmr7yb95bbhi00bnvhnlx4crbx06wridhz2lp23";
        libraryHaskellDepends = [
          attoparsec attoparsec-data base optparse-applicative text
          text-builder
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "optparse-applicative_0_16_0_0" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, bytestring, process
+     , QuickCheck, transformers, transformers-compat
+     }:
+     mkDerivation {
+       pname = "optparse-applicative";
+       version = "0.16.0.0";
+       sha256 = "0aybamakg9zjac0b78lhfa1bvilkb76yryis6h0pf5j1khrkri89";
+       libraryHaskellDepends = [
+         ansi-wl-pprint base process transformers transformers-compat
+       ];
+       testHaskellDepends = [ base bytestring QuickCheck ];
+       description = "Utilities and combinators for parsing command line options";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "optparse-applicative-simple" = callPackage
     ({ mkDerivation, attoparsec, attoparsec-data, base-prelude
      , optparse-applicative, rerebase, text
···
        pname = "packdeps";
        version = "0.6.0.0";
        sha256 = "10hrsshzljs6yjzgpw6kpdc4fx4xrbafwicpapcmmj1y66rj00dz";
+       revision = "1";
+       editedCabalFile = "02akm54nkfw8jzc8b1b49pkbn4h73s5f968gyafmnq9jla0rcsjg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "pandoc-types";
        version = "1.20";
        sha256 = "0wz89ywyhvxz8daw4ia132kg6ynx5y4wva4g899wvq4kyjy1dixa";
+       revision = "1";
+       editedCabalFile = "16l4gy0v34nrb6z3pag6i3gl6m4af5j6wg6yzyiga124xpqzhql3";
        libraryHaskellDepends = [
          aeson base bytestring containers deepseq ghc-prim QuickCheck syb
          text transformers
···
      }:
      mkDerivation {
        pname = "pantry";
-       version = "0.4.0.1";
-       sha256 = "182aiwwgrsdj9f4x71q1grj674d91djp4q6bz2l51ly5dsjy5wbf";
+       version = "0.4.0.2";
+       sha256 = "13rrd64qn96r9w623lns4cngalc2c0p2z1xzc0wv35kr3psnxwb4";
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring Cabal casa-client casa-types
          conduit conduit-extra containers cryptonite cryptonite-conduit
···
        broken = true;
      }) {};
 
+  "periodic-client" = callPackage
+    ({ mkDerivation, base, binary, byteable, bytestring, hslogger
+     , metro, metro-socket, mtl, periodic-common, resource-pool
+     , transformers, unliftio
+     }:
+     mkDerivation {
+       pname = "periodic-client";
+       version = "1.1.7.1";
+       sha256 = "0d9ngiq064fajiy2c4sddpgr93ia13iv83rdnvbk05x7agi0srjb";
+       libraryHaskellDepends = [
+         base binary byteable bytestring hslogger metro metro-socket mtl
+         periodic-common resource-pool transformers unliftio
+       ];
+       description = "Periodic task system haskell client";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "periodic-client-exe" = callPackage
+    ({ mkDerivation, base, binary, boxes, bytestring
+     , data-default-class, deepseq, http-types, metro, metro-socket
+     , metro-transport-tls, metro-transport-websockets
+     , metro-transport-xor, periodic-client, periodic-common, process
+     , scotty, streaming-commons, text, unix-time, unliftio, warp
+     , websockets
+     }:
+     mkDerivation {
+       pname = "periodic-client-exe";
+       version = "1.1.7.1";
+       sha256 = "0mgcvkc4sw7f1idjnhcj6qinnm3w47as6zjx2s8cxyfxn0ma73ll";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base binary boxes bytestring data-default-class deepseq http-types
+         metro metro-socket metro-transport-tls metro-transport-websockets
+         metro-transport-xor periodic-client periodic-common process scotty
+         streaming-commons text unix-time unliftio warp websockets
+       ];
+       description = "Periodic task system haskell client executables";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "periodic-common" = callPackage
+    ({ mkDerivation, base, binary, byteable, bytestring, entropy
+     , hashable, hslogger, metro, text, unliftio, vector
+     }:
+     mkDerivation {
+       pname = "periodic-common";
+       version = "1.1.7.0";
+       sha256 = "17rbzps7s4vwpf6390lz158hj1m5w6b791v8srg4mz9wd493iwbg";
+       libraryHaskellDepends = [
+         base binary byteable bytestring entropy hashable hslogger metro
+         text unliftio vector
+       ];
+       description = "Periodic task system common";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "periodic-polynomials" = callPackage
     ({ mkDerivation, base, vector }:
      mkDerivation {
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "periodic-server" = callPackage
+    ({ mkDerivation, async, base, base64-bytestring, binary, byteable
+     , bytestring, direct-sqlite, entropy, filepath, hslogger, metro
+     , metro-socket, metro-transport-tls, metro-transport-websockets
+     , metro-transport-xor, mtl, network, periodic-common
+     , postgresql-simple, psqueues, resource-pool, stm, transformers
+     , unliftio, unordered-containers
+     }:
+     mkDerivation {
+       pname = "periodic-server";
+       version = "1.1.7.1";
+       sha256 = "1gvx5n86xm14yp07ag57mw5pfig0ldpnwmg1y4vrj003k046n29p";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async base base64-bytestring binary byteable bytestring
+         direct-sqlite entropy filepath hslogger metro mtl network
+         periodic-common postgresql-simple psqueues resource-pool stm
+         transformers unliftio unordered-containers
+       ];
+       executableHaskellDepends = [
+         base bytestring hslogger metro metro-socket metro-transport-tls
+         metro-transport-websockets metro-transport-xor periodic-common
+         unliftio
+       ];
+       description = "Periodic task system haskell server";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "perm" = callPackage
     ({ mkDerivation, base, catch-fd, HUnit, mtl, test-framework
      , test-framework-hunit, transformers
···
        librarySystemDepends = [ gu pgf ];
        description = "Bindings to the C version of the PGF runtime";
        license = stdenv.lib.licenses.lgpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {gu = null; inherit (pkgs) pgf;};
 
   "pgm" = callPackage
···
 
   "pipes" = callPackage
     ({ mkDerivation, base, criterion, exceptions, mmorph, mtl
-     , optparse-applicative, QuickCheck, semigroups, test-framework
-     , test-framework-quickcheck2, transformers, void
-     }:
-     mkDerivation {
-       pname = "pipes";
-       version = "4.3.13";
-       sha256 = "1ch3xr5f5if0psd3lsyrpkwrgh36synnzqcpimghprys68l4zfkn";
-       libraryHaskellDepends = [
-         base exceptions mmorph mtl semigroups transformers void
-       ];
-       testHaskellDepends = [
-         base mtl QuickCheck test-framework test-framework-quickcheck2
-         transformers
-       ];
-       benchmarkHaskellDepends = [
-         base criterion mtl optparse-applicative transformers
-       ];
-       description = "Compositional pipelines";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "pipes_4_3_14" = callPackage
-    ({ mkDerivation, base, criterion, exceptions, mmorph, mtl
      , optparse-applicative, QuickCheck, test-framework
      , test-framework-quickcheck2, transformers, void
      }:
···
        ];
        description = "Compositional pipelines";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "pipes-aeson" = callPackage
···
        ];
        description = "run a subprocess, combining stdout and stderr";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "plist" = callPackage
···
      }:
      mkDerivation {
        pname = "polysemy-webserver";
-       version = "0.2.0.0";
-       sha256 = "0ld1ncal2isibzjbq72jk3dp8rgvz32zyvisjdd79wxwxg1z1nad";
+       version = "0.2.1.0";
+       sha256 = "1kzswc20c2a720r46krphwckp6bcgkinw59immjpwvixxdfd0bma";
        libraryHaskellDepends = [
          base bytestring http-types polysemy polysemy-plugin wai
          wai-websockets warp websockets
···
      }) {};
 
   "postgres-websockets" = callPackage
-    ({ mkDerivation, aeson, alarmclock, auto-update, base
+    ({ mkDerivation, aeson, alarmclock, async, auto-update, base
      , base64-bytestring, bytestring, contravariant, either, envparse
      , hasql, hasql-notifications, hasql-pool, hspec, hspec-wai
-     , hspec-wai-json, http-types, jose, lens, postgresql-libpq
-     , protolude, retry, stm, stm-containers, stringsearch, text, time
-     , transformers, unordered-containers, wai, wai-app-static
-     , wai-extra, wai-websockets, warp, websockets
+     , hspec-wai-json, http-types, jose, lens, lens-aeson, network
+     , postgresql-libpq, protolude, retry, stm, stm-containers
+     , stringsearch, text, time, unordered-containers, wai
+     , wai-app-static, wai-extra, wai-websockets, warp, websockets
      }:
      mkDerivation {
        pname = "postgres-websockets";
-       version = "0.7.0.0";
-       sha256 = "0kjwj81ccn29iflx3sszb8sjap9zvi22sm1dm4vg7qv33n0jgfmp";
+       version = "0.8.0.1";
+       sha256 = "0a56dpj90nmrinjgxaipgbsfl5ligx3iydcnijxpwy6vwbjijnmi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson alarmclock base bytestring contravariant either hasql
-         hasql-notifications hasql-pool http-types jose lens
-         postgresql-libpq protolude retry stm stm-containers stringsearch
-         text time unordered-containers wai wai-websockets websockets
-       ];
-       executableHaskellDepends = [
-         auto-update base base64-bytestring bytestring envparse hasql
-         hasql-pool http-types protolude text time transformers wai
-         wai-app-static wai-extra warp
+         aeson alarmclock async auto-update base base64-bytestring
+         bytestring contravariant either envparse hasql hasql-notifications
+         hasql-pool http-types jose lens postgresql-libpq protolude retry
+         stm stm-containers stringsearch text time unordered-containers wai
+         wai-app-static wai-extra wai-websockets warp websockets
        ];
+     , text, time, unordered-containers, uuid, vector
        testHaskellDepends = [
          aeson base hasql hasql-notifications hasql-pool hspec hspec-wai
-         hspec-wai-json http-types protolude stm time unordered-containers
-         wai-extra
+         hspec-wai-json http-types lens lens-aeson network protolude stm
+         time unordered-containers wai-extra websockets
        ];
        description = "Middleware to map LISTEN/NOTIFY messages to Websockets";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "predicate-typed" = callPackage
-    ({ mkDerivation, aeson, base, binary, bytestring, comonad
-     , containers, deepseq, directory, doctest, hashable, lens, mtl
-     , pcre-heavy, pcre-light, pretty, pretty-terminal, QuickCheck, safe
-     , stm, tasty, tasty-hunit, tasty-quickcheck, template-haskell, text
-     , th-lift, these, time, tree-view
+    ({ mkDerivation, aeson, aeson-pretty, base, binary, bytestring
+     , comonad, containers, deepseq, directory, doctest, hashable, lens
+     , mtl, pcre-heavy, pcre-light, pretty, pretty-terminal, QuickCheck
+     , safe, stm, string-conversions, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, text, th-lift, these, time
+     , tree-view
      }:
      mkDerivation {
        pname = "predicate-typed";
-       version = "0.7.2.0";
-       sha256 = "0ikgar72pc1cracqfswzajr2razv98iyanmf7vwd9nkqxkwyqkpk";
+       version = "0.7.3.0";
+       sha256 = "124f9bdvq30xaadg6020q0pmfv56mpkw25ws306xp8mfs61g1src";
        libraryHaskellDepends = [
-         aeson base binary bytestring comonad containers deepseq directory
-         hashable lens mtl pcre-heavy pcre-light pretty pretty-terminal
-         QuickCheck safe template-haskell text th-lift these time tree-view
+         aeson aeson-pretty base binary bytestring comonad containers
+         deepseq directory hashable lens mtl pcre-heavy pcre-light pretty
+         pretty-terminal QuickCheck safe string-conversions template-haskell
+         text th-lift these time tree-view
        ];
        testHaskellDepends = [
-         aeson base binary bytestring comonad containers deepseq directory
-         doctest hashable lens mtl pcre-heavy pcre-light pretty
-         pretty-terminal QuickCheck safe stm tasty tasty-hunit
-         tasty-quickcheck template-haskell text th-lift these time tree-view
+         aeson aeson-pretty base binary bytestring comonad containers
+         deepseq directory doctest hashable lens mtl pcre-heavy pcre-light
+         pretty pretty-terminal QuickCheck safe stm string-conversions tasty
+         tasty-hunit tasty-quickcheck template-haskell text th-lift these
+         time tree-view
        ];
        description = "Predicates, Refinement types and Dsl";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.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
+     }:
+     mkDerivation {
+       pname = "proto3-wire";
+       version = "1.2.0";
+       sha256 = "1xrnrh4njnw6af8xxg9xhcxrscg0g644jx4l9an4iqz6xmjp2nk2";
+       libraryHaskellDepends = [
+         base bytestring cereal containers deepseq ghc-prim hashable
+         parameterized primitive QuickCheck safe text transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         base bytestring cereal doctest QuickCheck tasty tasty-hunit
+         tasty-quickcheck text transformers vector
+       ];
+       description = "A low-level implementation of the Protocol Buffers (version 3) wire format";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "protobuf" = callPackage
     ({ mkDerivation, base, base-orphans, bytestring, cereal, containers
      , data-binary-ieee754, deepseq, hex, HUnit, mtl, QuickCheck, tagged
···
        broken = true;
      }) {};
 
+  "qlinear" = callPackage
+    ({ mkDerivation, base, haskell-src-exts, haskell-src-meta, hspec
+     , linear, parsec, split, template-haskell
+     }:
+     mkDerivation {
+       pname = "qlinear";
+       version = "0.1.2.0";
+       sha256 = "1q1xd3sh5b5kjp9wb24v2z9dbjk75dwk286f0gda4y460h4zkp8z";
+       libraryHaskellDepends = [
+         base haskell-src-exts haskell-src-meta linear parsec split
+         template-haskell
+       ];
+       testHaskellDepends = [
+         base haskell-src-exts haskell-src-meta hspec linear parsec split
+         template-haskell
+       ];
+       description = "Typesafe library for linear algebra";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "qm-interpolated-string" = callPackage
     ({ mkDerivation, base, bytestring, haskell-src-meta, hspec
      , template-haskell, text
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "qrcode-juicypixels_0_8_2" = callPackage
+    ({ mkDerivation, base, base64-bytestring, bytestring, JuicyPixels
+     , qrcode-core, text, vector
+     }:
+     mkDerivation {
+       pname = "qrcode-juicypixels";
+       version = "0.8.2";
+       sha256 = "0kiyi084hmd2l50fd8miwgw0y94sd1lkf34jw7z3sb33bbp70f3g";
+       libraryHaskellDepends = [
+         base base64-bytestring bytestring JuicyPixels qrcode-core text
+         vector
+       ];
+       description = "Converts a qrcode-core image to JuicyPixels";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "qsem" = callPackage
     ({ mkDerivation, base, ghc-prim }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "record-dot-preprocessor_0_2_6" = callPackage
+    ({ mkDerivation, base, extra, filepath, ghc, record-hasfield
+     , uniplate
+     }:
+     mkDerivation {
+       pname = "record-dot-preprocessor";
+       version = "0.2.6";
+       sha256 = "0xnlzs74nxcw6yms5zbd50wnzy3n0i91rf0ss9ywc9bw18d2lbmh";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base extra ghc uniplate ];
+       executableHaskellDepends = [ base extra ];
+       testHaskellDepends = [ base extra filepath record-hasfield ];
+       description = "Preprocessor to allow record.field syntax";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "record-encode" = callPackage
     ({ mkDerivation, base, doctest, generics-sop, hspec, QuickCheck
      , vector
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "req_3_4_0" = callPackage
+  "req_3_5_0" = callPackage
     ({ mkDerivation, aeson, authenticate-oauth, base, blaze-builder
      , bytestring, case-insensitive, connection, exceptions, hspec
      , hspec-core, hspec-discover, http-api-data, http-client
      , http-client-tls, http-types, modern-uri, monad-control, mtl
      , QuickCheck, retry, template-haskell, text, time, transformers
-     , transformers-base, unordered-containers
+     , transformers-base, unliftio-core, unordered-containers
      }:
      mkDerivation {
        pname = "req";
-       version = "3.4.0";
-       sha256 = "1ffgrk45fa3knrl9cp01n7yl9gakd27mvyy1zq2j67h82bqz9qqa";
+       version = "3.5.0";
+       sha256 = "0ydz6m3d87apmkd8i55q4r57cqd65sssxz972p6vv77v3r471n26";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson authenticate-oauth base blaze-builder bytestring
          case-insensitive connection exceptions http-api-data http-client
          http-client-tls http-types modern-uri monad-control mtl retry
          template-haskell text time transformers transformers-base
+         unliftio-core
        ];
        testHaskellDepends = [
          aeson base blaze-builder bytestring case-insensitive hspec
···
      }:
      mkDerivation {
        pname = "rescue";
-       version = "0.2.0";
-       sha256 = "09mlamir7n2jjm50qxlws8w9qa5xzrm6fr21vsh9gpwf8pkd98qw";
+       version = "0.2.1";
+       sha256 = "1rb7apdlpm69695hcpimmyjn5ar8lld8q1hgag86jsww5dfn2mp7";
        libraryHaskellDepends = [
          base exceptions ghc mtl text transformers world-peace
        ];
···
      }:
      mkDerivation {
        pname = "rio";
-       version = "0.1.17.0";
-       sha256 = "0zs7s67fk1g1hckxk2iii2ad2hhsl9l1j3dkcdb7imzdha13q9rd";
-       libraryHaskellDepends = [
-         base bytestring containers deepseq directory exceptions filepath
-         hashable microlens microlens-mtl mtl primitive process text time
-         typed-process unix unliftio unliftio-core unordered-containers
-         vector
-       ];
-       testHaskellDepends = [
-         base bytestring containers deepseq directory exceptions filepath
-         hashable hspec microlens microlens-mtl mtl primitive process
-         QuickCheck text time typed-process unix unliftio unliftio-core
-         unordered-containers vector
-       ];
-       description = "A standard library for Haskell";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "rio_0_1_18_0" = callPackage
-    ({ mkDerivation, base, bytestring, containers, deepseq, directory
-     , exceptions, filepath, hashable, hspec, microlens, microlens-mtl
-     , mtl, primitive, process, QuickCheck, text, time, typed-process
-     , unix, unliftio, unliftio-core, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "rio";
        version = "0.1.18.0";
        sha256 = "11f1cxa9c90d7hgqn9bl08l499n2dzdj31f9pw9acb1nrlx5hik8";
        libraryHaskellDepends = [
···
        ];
        description = "A standard library for Haskell";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "rio-orphans" = callPackage
···
      }:
      mkDerivation {
        pname = "rio-prettyprint";
-       version = "0.1.0.0";
-       sha256 = "0n8ldc73i0954c6s8jh0hibxrisp84yh5pcxv3x3q0wg4v2xvr0m";
-       revision = "2";
-       editedCabalFile = "1hvhjqy7kfk7fglx1rw8axscy0dfzqwd1564awnwdhvmf8silkkn";
-       libraryHaskellDepends = [
-         aeson annotated-wl-pprint ansi-terminal array base Cabal colour mtl
-         path rio text
-       ];
-       description = "Pretty-printing for RIO";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "rio-prettyprint_0_1_1_0" = callPackage
-    ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, array
-     , base, Cabal, colour, mtl, path, rio, text
-     }:
-     mkDerivation {
-       pname = "rio-prettyprint";
        version = "0.1.1.0";
        sha256 = "1h092l46pfm6k3n0vb6c67gb64kahzc97qv45rhvp0cq2y5bqykf";
        libraryHaskellDepends = [
···
        ];
        description = "Pretty-printing for RIO";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "riot" = callPackage
···
      }) {};
 
   "sak" = callPackage
-    ({ mkDerivation, base, brotli, bytestring, bz2, cpphs, directory
-     , filepath, lz4-hs, lzlib, lzma, lzo, optparse-applicative
-     , parallel-io, snappy-lazy, zlib, zstd
+    ({ mkDerivation, base, bytestring, bz2, cpphs, directory, filepath
+     , lz4-hs, lzlib, lzma, lzo, optparse-applicative, parallel-io
+     , unix-compat, zlib, zstd
      }:
      mkDerivation {
        pname = "sak";
-       version = "0.1.2.5";
-       sha256 = "1xz3g7ksq1v8239xq2cddprlq4g8imid002w7wak15kv8aqvil1l";
+       version = "0.1.3.0";
+       sha256 = "1khws0z9v91vz722k6y0b99ffy2vd04myvpww4p1i32396dhczln";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base brotli bytestring bz2 directory filepath lz4-hs lzlib lzma lzo
-         optparse-applicative parallel-io snappy-lazy zlib zstd
+         base bytestring bz2 directory filepath lz4-hs lzlib lzma lzo
+         optparse-applicative parallel-io unix-compat zlib zstd
        ];
        executableToolDepends = [ cpphs ];
        description = "Compression command-line tool";
···
        ];
        description = "Work stealing scheduler";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "schedyield" = callPackage
···
        broken = true;
      }) {sedna = null;};
 
+  "seitz-symbol" = callPackage
+    ({ mkDerivation, base, doctest, hspec, matrix, matrix-as-xyz
+     , parsec, symmetry-operations-symbols
+     }:
+     mkDerivation {
+       pname = "seitz-symbol";
+       version = "0.1.0.0";
+       sha256 = "1x6374xaqgrf9ygjb9rffhpn1y5fla2gf0b0xj93r3bj6pf1w0qh";
+       libraryHaskellDepends = [
+         base matrix matrix-as-xyz parsec symmetry-operations-symbols
+       ];
+       testHaskellDepends = [
+         base doctest hspec matrix matrix-as-xyz parsec
+         symmetry-operations-symbols
+       ];
+       description = "Read and Display Seitz Symbol";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "selda" = callPackage
     ({ mkDerivation, base, bytestring, containers, exceptions, mtl
      , random, text, time, uuid-types
···
     ({ mkDerivation, aeson, base, servant }:
      mkDerivation {
        pname = "servant-jsonrpc";
-       version = "1.0.1";
-       sha256 = "0hizazwng0pcxd8p0n04xlgrx3vbr7nwc2k9s143q6yc6hp0dlj4";
+       version = "1.1.0";
+       sha256 = "0qy2al8waycarh5973c43bdd9g4a9032waknjsbykhflwglvwmv5";
        libraryHaskellDepends = [ aeson base servant ];
        description = "JSON-RPC messages and endpoints";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "servant-jsonrpc-client";
-       version = "1.0.1";
-       sha256 = "0s9ii02mfgyissyq4dbs9cqm3shrgiysjkhwgs6c0s30qqakjald";
+       version = "1.1.0";
+       sha256 = "0d18qajwpq6np0a61i5qm1z7iwvqrmgixg627diwr1xh4ws1ij8d";
        libraryHaskellDepends = [
          aeson base servant servant-client-core servant-jsonrpc
        ];
···
      }:
      mkDerivation {
        pname = "servant-jsonrpc-server";
-       version = "2.0.0";
-       sha256 = "0svnbsxzwfxdbyjhgq1hxxpjv96dzqkwg44bnq24lc5jk7j244sk";
+       version = "2.1.0";
+       sha256 = "09byg58qm4r9kbcxzr6jbyg5ziih58p0za8ihq4y8w60mznpb055";
        libraryHaskellDepends = [
          aeson base containers mtl servant servant-jsonrpc servant-server
        ];
···
        pname = "serversession";
        version = "1.0.1";
        sha256 = "08j8v6a2018bmvwsb7crdg0ajak74jggb073pdpx9s0pf3cfzyrz";
-       revision = "1";
-       editedCabalFile = "0sxr4c7nk16n51y53qwwjnvgqjdqjm1ybaqkf0r8y91fac8x47b5";
+       revision = "2";
+       editedCabalFile = "0i5faxzxgvpfylmrr175f8l4asyh4phncc90jkfag53gnspcv028";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring data-default hashable nonce
          path-pieces text time transformers unordered-containers
···
        ];
        description = "Invertible grammar combinators for S-expressions";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "sexp-grammar_2_2_1" = callPackage
+    ({ mkDerivation, alex, array, base, bytestring, containers
+     , criterion, deepseq, happy, invertible-grammar, prettyprinter
+     , QuickCheck, recursion-schemes, scientific, semigroups, tasty
+     , tasty-hunit, tasty-quickcheck, text, utf8-string
+     }:
+     mkDerivation {
+       pname = "sexp-grammar";
+       version = "2.2.1";
+       sha256 = "0nf3b3cibqi2jv9jg742jknqpfgwvc7iwjw7a2jgpf55nrgs6lvz";
+       libraryHaskellDepends = [
+         array base bytestring containers deepseq invertible-grammar
+         prettyprinter recursion-schemes scientific semigroups text
+         utf8-string
+       ];
+       libraryToolDepends = [ alex happy ];
+       testHaskellDepends = [
+         base containers invertible-grammar prettyprinter QuickCheck
+         scientific semigroups tasty tasty-hunit tasty-quickcheck text
+         utf8-string
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion deepseq text
+       ];
+       description = "Invertible grammar combinators for S-expressions";
+       license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "sexp-show" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "shake-plus_0_3_1_0" = callPackage
+  "shake-plus_0_3_2_0" = callPackage
     ({ mkDerivation, base, extra, path, rio, shake }:
      mkDerivation {
        pname = "shake-plus";
-       version = "0.3.1.0";
-       sha256 = "1a1dj61sl0acil3bfw84nlvsi64f6bmlxbb4vb6q5rqarnhvk5qj";
+       version = "0.3.2.0";
+       sha256 = "0cgn1hgxp3kly7yp4s8mx714p1gnf30jpp6vjl47l19vc21hfzj5";
        libraryHaskellDepends = [ base extra path rio shake ];
        description = "Re-export of Shake using well-typed paths and ReaderT";
        license = stdenv.lib.licenses.mit;
···
        pname = "shh";
        version = "0.7.0.8";
        sha256 = "1f8r8wymdbv8j2m3apdw75xqq2c1s4wr694qhxljvwa9r0s326wf";
+       revision = "1";
+       editedCabalFile = "03gvwv2hxrp8ncfmwhp7hn8xah5mx9fgm298s83l78grqjlzdbil";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "squeeze";
-       version = "1.0.4.18";
-       sha256 = "0s10k1fyh8xrsf0cbj32r8f7clcj6pfyc39b9bmgsixg1qngjbdj";
+       version = "1.0.4.19";
+       sha256 = "0zb4nbgwlifzaw28g09qhvvjk8a795zww0b746bj98wgzyxp6a50";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "strict-base-types_0_7" = callPackage
+    ({ mkDerivation, aeson, base, quickcheck-instances, strict
+     , strict-lens
+     }:
+     mkDerivation {
+       pname = "strict-base-types";
+       version = "0.7";
+       sha256 = "079pa6w3f5i5kv1v6mwhp2k0siyywnk3igm93y2kaz37f352x5jn";
+       libraryHaskellDepends = [
+         aeson base quickcheck-instances strict strict-lens
+       ];
+       description = "Strict variants of the types provided in base";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "strict-concurrency" = callPackage
     ({ mkDerivation, base, deepseq }:
      mkDerivation {
···
        libraryHaskellDepends = [ base lens strict ];
        description = "Lenses for types in strict package";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "strict-list" = callPackage
···
        libraryHaskellDepends = [ base optics-core strict ];
        description = "Optics for types in strict package";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "strict-tuple" = callPackage
···
      }:
      mkDerivation {
        pname = "stylish-haskell";
-       version = "0.11.0.0";
-       sha256 = "124dn46ddxfcjyrmwjwijqan0dd55zzx9nwckg1df8b6al6k0x3j";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base bytestring Cabal containers directory file-embed
-         filepath haskell-src-exts HsYAML HsYAML-aeson mtl semigroups syb
-         text
-       ];
-       executableHaskellDepends = [
-         aeson base bytestring Cabal containers directory file-embed
-         filepath haskell-src-exts HsYAML HsYAML-aeson mtl
-         optparse-applicative strict syb
-       ];
-       testHaskellDepends = [
-         aeson base bytestring Cabal containers directory file-embed
-         filepath haskell-src-exts HsYAML HsYAML-aeson HUnit mtl random syb
-         test-framework test-framework-hunit text
-       ];
-       description = "Haskell code prettifier";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "stylish-haskell_0_11_0_3" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
-     , directory, file-embed, filepath, haskell-src-exts, HsYAML
-     , HsYAML-aeson, HUnit, mtl, optparse-applicative, random
-     , semigroups, strict, syb, test-framework, test-framework-hunit
-     , text
-     }:
-     mkDerivation {
-       pname = "stylish-haskell";
        version = "0.11.0.3";
        sha256 = "10svl5q95n9i76rqvlxibi784qzvdyg8qfl1xwk7c32y84nyfibn";
        isLibrary = true;
···
        ];
        description = "Haskell code prettifier";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "stylist" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "summer" = callPackage
+    ({ mkDerivation, base, vector }:
+     mkDerivation {
+       pname = "summer";
+       version = "0.1.2.0";
+       sha256 = "1xcfw3f4y53a9jdj2a7jy32pp5pcvqsv78gblkjj1bxvsijwa4ab";
+       libraryHaskellDepends = [ base vector ];
+       testHaskellDepends = [ base ];
+       description = "An implementation of extensible products and sums";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "summoner" = callPackage
     ({ mkDerivation, aeson, base, colourista, containers, directory
      , filepath, generic-data, gitrev, hedgehog, hspec, hspec-hedgehog
···
        license = stdenv.lib.licenses.lgpl21;
      }) {};
 
+  "swiss-ephemeris" = callPackage
+    ({ mkDerivation, base, directory, hspec, hspec-discover }:
+     mkDerivation {
+       pname = "swiss-ephemeris";
+       version = "0.1.0.2";
+       sha256 = "0kjph3dy7ii767zpjdqi2ya08vgahhwkbf1fp48n26vfilcwppc9";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base directory hspec ];
+       testToolDepends = [ hspec-discover ];
+       description = "Haskell bindings for the Swiss Ephemeris C library";
+       license = stdenv.lib.licenses.gpl2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "sws" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
      , containers, cryptonite, directory, filepath, hourglass
···
      }:
      mkDerivation {
        pname = "symmetry-operations-symbols";
-       version = "0.0.1.4";
-       sha256 = "0ki9cmxpwds48chdb2mp4ysn6wh8qmmh5srspmjf4s0knaapzk2j";
+       version = "0.0.2.1";
+       sha256 = "0y9m1z72kh8lhmig0lpp67p3s74s706y6lbzlr5hk47mpcw7fymh";
        libraryHaskellDepends = [ base matrix matrix-as-xyz parsec ];
        testHaskellDepends = [
          base doctest hspec matrix matrix-as-xyz parsec QuickCheck
···
        executablePkgconfigDepends = [ gtk3 ];
        description = "A desktop bar similar to xmobar, but with more GUI";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gtk3;};
 
   "tag-bits" = callPackage
···
      }:
      mkDerivation {
        pname = "taskell";
-       version = "1.9.3.0";
-       sha256 = "06pdfi5bw2ga0pizq01x35gp8f90c8gr4ivbm5k4a7xv6pwr8mf0";
+       version = "1.10.0";
+       sha256 = "14syiis60fds1r295d6nlvw0mn1d1d6ly0j69r9srbcbrbb2j7yw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover tasty-discover ];
        description = "Docker containers for your integration tests";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "testing-feat" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "thread-supervisor_0_2_0_0" = callPackage
+    ({ mkDerivation, base, clock, containers, data-default, hspec
+     , hspec-discover, QuickCheck, unliftio
+     }:
+     mkDerivation {
+       pname = "thread-supervisor";
+       version = "0.2.0.0";
+       sha256 = "1k42k6c2h0xs7h4gcfsjghr5jp1q2w7ay1drlfw2ghl8zmfh2pnv";
+       libraryHaskellDepends = [
+         base clock containers data-default unliftio
+       ];
+       testHaskellDepends = [
+         base clock data-default hspec QuickCheck unliftio
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A simplified implementation of Erlang/OTP like supervisor over thread";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "threadPool" = callPackage
     ({ mkDerivation, base, process }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "timers";
-       version = "0.2.0.3";
-       sha256 = "0q4w41jdhf5ildcdl94lgfn06fg275hf04dpah3l6vva24d8alj5";
+       version = "0.2.0.4";
+       sha256 = "031jladbn54gr5jcljpw5r1hr82403gd6g9vszcv2pj8z82p21ab";
        libraryHaskellDepends = [
          base lifted-base monad-control suspend transformers-base
        ];
···
        broken = true;
      }) {};
 
-  "tldr_0_7_1" = callPackage
+  "tldr_0_8_0" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, cmark, containers
      , directory, filepath, optparse-applicative, semigroups, tasty
      , tasty-golden, text, typed-process
      }:
      mkDerivation {
        pname = "tldr";
-       version = "0.7.1";
-       sha256 = "1vc9rxyxczs7kswrjq2c4lziwvnwri53ng8yq4724hpjvybiqs57";
+       version = "0.8.0";
+       sha256 = "02by0mj2mk2k8xwcn92zd0cns8fj6fibi0wx5h2zlnm5aj53nffv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ansi-terminal base bytestring cmark text
+         ansi-terminal base bytestring cmark containers directory filepath
+         optparse-applicative semigroups text typed-process
        ];
-       executableHaskellDepends = [
-         base containers directory filepath optparse-applicative semigroups
-         typed-process
-       ];
+       executableHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-golden ];
        description = "Haskell tldr client";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "trifecta";
        version = "2.1";
        sha256 = "0fr326lzf38m20h2g4189nsyml9w3128924zbd3cd93cgfqcc9bs";
-       revision = "1";
-       editedCabalFile = "17s7wrc7zmvh1lf0ky96j7797rdgxrc10man8kf1nr24907pxw91";
+       revision = "2";
+       editedCabalFile = "17b0wxwgf52xdm597x0ybq1g2yrvfihl32jpd989xsm6n7s7y21a";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          ansi-terminal array base blaze-builder blaze-html blaze-markup
···
        benchmarkHaskellDepends = [ base criterion text ];
        description = "Shell programming, Haskell-style";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "turtle_1_5_20" = 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.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 = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "turtle-options" = callPackage
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.6.3";
-       sha256 = "0w0887xrkai5xhky245gnjjfq7d8cw43l90rmfvhqxwdf7jkkxc8";
+       version = "3.6.4";
+       sha256 = "15zy3q8nk2myp6p6nqpi5sabdi4r0d5jb20g8df1x7r3rqr2lfh2";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        librarySystemDepends = [ vulkan ];
        description = "Bindings to the Vulkan graphics API";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "wai-app-static_3_1_7_2" = callPackage
+    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
+     , containers, cryptonite, directory, file-embed, filepath, hspec
+     , http-date, http-types, memory, mime-types, mockery, network
+     , old-locale, optparse-applicative, template-haskell, temporary
+     , text, time, transformers, unix-compat, unordered-containers, wai
+     , wai-extra, warp, zlib
+     }:
+     mkDerivation {
+       pname = "wai-app-static";
+       version = "3.1.7.2";
+       sha256 = "138gd5482psq0wbm8s1az672lksi7vbavq6ayiyjkliivf6xpry8";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base blaze-html blaze-markup bytestring containers cryptonite
+         directory file-embed filepath http-date http-types memory
+         mime-types old-locale optparse-applicative template-haskell text
+         time transformers unix-compat unordered-containers wai wai-extra
+         warp zlib
+       ];
+       executableHaskellDepends = [
+         base bytestring containers directory mime-types text
+       ];
+       testHaskellDepends = [
+         base bytestring filepath hspec http-date http-types mime-types
+         mockery network old-locale temporary text time transformers
+         unix-compat wai wai-extra zlib
+       ];
+       description = "WAI application for static serving";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "wai-cli" = callPackage
     ({ mkDerivation, ansi-terminal, base, http-types, iproute
      , monads-tf, network, options, socket-activation, stm
···
      }:
      mkDerivation {
        pname = "weekdaze";
-       version = "0.0.0.2";
-       sha256 = "17i8pq4xfc6mxdphc7xiiwlnqw3m70sh7d3pjnql33m1083kbkxb";
+       version = "0.0.0.3";
+       sha256 = "1khnizhk45qbjrxq24bfs183wbmrdxax7k09mjm9717wb350v6k6";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }) {};
 
   "xlsx" = callPackage
-    ({ mkDerivation, attoparsec, base, base64-bytestring, binary-search
-     , bytestring, conduit, containers, criterion, data-default, deepseq
-     , Diff, errors, extra, filepath, groom, lens, mtl, network-uri
-     , old-locale, raw-strings-qq, safe, smallcheck, tasty, tasty-hunit
-     , tasty-smallcheck, text, time, transformers, vector, xeno
-     , xml-conduit, zip-archive, zlib
-     }:
-     mkDerivation {
-       pname = "xlsx";
-       version = "0.8.0";
-       sha256 = "1wp2ybkf5z4x87a73yygi3g1nqjy6pfb1wdwyvmjqk64ibjz0p7d";
-       libraryHaskellDepends = [
-         attoparsec base base64-bytestring binary-search bytestring conduit
-         containers data-default deepseq errors extra filepath lens mtl
-         network-uri old-locale safe text time transformers vector xeno
-         xml-conduit zip-archive zlib
-       ];
-       testHaskellDepends = [
-         base bytestring containers Diff groom lens mtl raw-strings-qq
-         smallcheck tasty tasty-hunit tasty-smallcheck text time vector
-         xml-conduit
-       ];
-       benchmarkHaskellDepends = [ base bytestring criterion ];
-       description = "Simple and incomplete Excel file parser/writer";
-       license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "xlsx_0_8_1" = callPackage
     ({ mkDerivation, attoparsec, base, base64-bytestring, binary-search
      , bytestring, conduit, containers, criterion, data-default, deepseq
      , Diff, errors, extra, filepath, groom, lens, mtl, network-uri
···
 
   "yesod" = callPackage
     ({ mkDerivation, aeson, base, bytestring, conduit
-     , data-default-class, directory, fast-logger, monad-logger
-     , semigroups, shakespeare, streaming-commons, template-haskell
+     , data-default-class, directory, fast-logger, file-embed
+     , monad-logger, shakespeare, streaming-commons, template-haskell
      , text, unix, unordered-containers, wai, wai-extra, wai-logger
      , warp, yaml, yesod-core, yesod-form, yesod-persistent
      }:
      mkDerivation {
        pname = "yesod";
-       version = "1.6.0.2";
-       sha256 = "0dkaa7kzhdnqryfn8sbcbw5i1plkfckz1664gb1734fqadia32gq";
+       version = "1.6.1.0";
+       sha256 = "1jk55fm58ywp69khacw8n3qk2aybsrlh4bkinjgrah3w01kflmyw";
        libraryHaskellDepends = [
          aeson base bytestring conduit data-default-class directory
-         fast-logger monad-logger semigroups shakespeare streaming-commons
+         fast-logger file-embed monad-logger shakespeare streaming-commons
          template-haskell text unix unordered-containers wai wai-extra
          wai-logger warp yaml yesod-core yesod-form yesod-persistent
        ];
···
 
   "yesod-auth-basic" = callPackage
     ({ mkDerivation, base, base64-bytestring, bytestring, exceptions
-     , hlint, hspec, text, wai, word8, yesod, yesod-test
+     , hspec, monad-control, text, wai, word8, yesod, yesod-test
      }:
      mkDerivation {
        pname = "yesod-auth-basic";
-       version = "0.1.0.2";
-       sha256 = "0b4vyf731wb7idmbqz7n8zm4p7i7y66x94ph7kaxv1jvq05k7bxa";
+       version = "0.1.0.3";
+       sha256 = "0qm65ml82waxapq3v19k6x33cghgg6wg72p5h2j1ii329dv6293b";
        libraryHaskellDepends = [
-         base base64-bytestring bytestring exceptions text wai word8 yesod
+         base base64-bytestring bytestring exceptions monad-control text wai
+         word8 yesod
        ];
-       testHaskellDepends = [ base hlint hspec text yesod yesod-test ];
+       testHaskellDepends = [ base hspec text yesod yesod-test ];
        description = "Yesod Middleware for HTTP Basic Authentication";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "yesod-bin";
-       version = "1.6.0.5";
-       sha256 = "06klixw5qi12bxpll1bvyc5lngpkzd48qvq4r3v4vlppninsj2cd";
-       isLibrary = false;
-       isExecutable = true;
-       executableHaskellDepends = [
-         base bytestring Cabal conduit conduit-extra containers
-         data-default-class directory file-embed filepath fsnotify
-         http-client http-client-tls http-reverse-proxy http-types network
-         optparse-applicative process project-template say split stm
-         streaming-commons tar text time transformers transformers-compat
-         unliftio unordered-containers wai wai-extra warp warp-tls yaml zlib
-       ];
-       description = "The yesod helper executable";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "yesod-bin_1_6_0_6" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, conduit, conduit-extra
-     , containers, data-default-class, directory, file-embed, filepath
-     , fsnotify, http-client, http-client-tls, http-reverse-proxy
-     , http-types, network, optparse-applicative, process
-     , project-template, say, split, stm, streaming-commons, tar, text
-     , time, transformers, transformers-compat, unliftio
-     , unordered-containers, wai, wai-extra, warp, warp-tls, yaml, zlib
-     }:
-     mkDerivation {
-       pname = "yesod-bin";
        version = "1.6.0.6";
        sha256 = "044xk75pymw6limz08zicxp4lw8jqf6f2ilj8i2qw2h419w3ry9f";
        isLibrary = false;
···
        ];
        description = "The yesod helper executable";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yesod-bootstrap" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "zenacy-html" = callPackage
+    ({ mkDerivation, base, bytestring, containers, criterion
+     , data-default, dlist, extra, HUnit, mtl, pretty-show
+     , raw-strings-qq, safe, safe-exceptions, test-framework
+     , test-framework-hunit, text, transformers, vector, word8
+     }:
+     mkDerivation {
+       pname = "zenacy-html";
+       version = "2.0.1";
+       sha256 = "074iidhiwzajz207q4k7f8sdg6w4421qfwr2s905226jd2xm1680";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers data-default dlist extra mtl pretty-show
+         safe safe-exceptions text transformers vector word8
+       ];
+       executableHaskellDepends = [
+         base bytestring containers data-default dlist extra pretty-show
+         text vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers data-default dlist extra HUnit mtl
+         pretty-show raw-strings-qq test-framework test-framework-hunit text
+         transformers
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring containers criterion data-default dlist pretty-show
+         raw-strings-qq text
+       ];
+       description = "A standard compliant HTML parsing library";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "zenc" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "zlib";
-       version = "0.6.2.1";
-       sha256 = "1l11jraslcrp9d4wnhwfyhwk4fsiq1aq8i6vj81vcq1m2zzi1y7h";
-       revision = "1";
-       editedCabalFile = "0i9g71jvdw22bi9bi8dm5khwzcsv6cv8yadmf7afklg4xigxykfk";
-       libraryHaskellDepends = [ base bytestring ];
-       librarySystemDepends = [ zlib ];
-       testHaskellDepends = [
-         base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck
-       ];
-       description = "Compression and decompression in the gzip and zlib formats";
-       license = stdenv.lib.licenses.bsd3;
-     }) {inherit (pkgs) zlib;};
-
-  "zlib_0_6_2_2" = callPackage
-    ({ mkDerivation, base, bytestring, QuickCheck, tasty, tasty-hunit
-     , tasty-quickcheck, zlib
-     }:
-     mkDerivation {
-       pname = "zlib";
        version = "0.6.2.2";
        sha256 = "1fii0qfc60lfp93vwb78p2fv3jjyklgdhw4ms262z6cysq6qkd84";
        libraryHaskellDepends = [ base bytestring ];
···
        ];
        description = "Compression and decompression in the gzip and zlib formats";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {inherit (pkgs) zlib;};
 
   "zlib-bindings" = callPackage

pkgs/top-level/haskell-packages.nix

···
       buildLlvmPackages = buildPackages.llvmPackages_9;
       llvmPackages = pkgs.llvmPackages_9;
     };
+    ghc8102 = callPackage ../development/compilers/ghc/8.10.2.nix {
+      bootPkgs = packages.ghc865Binary;
+      inherit (buildPackages.python3Packages) sphinx;
+      buildLlvmPackages = buildPackages.llvmPackages_9;
+      llvmPackages = pkgs.llvmPackages_9;
+    };
     ghcHEAD = callPackage ../development/compilers/ghc/head.nix {
       bootPkgs = packages.ghc883; # no binary yet
       inherit (buildPackages.python3Packages) sphinx;
···
     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 { };
     };
     ghcHEAD = callPackage ../development/haskell-modules {