Merge pull request #96272 from NixOS/haskell-updates

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

pkgs/development/compilers/ghc/head.nix

···
 , # Whether to build terminfo.
   enableTerminfo ? !stdenv.targetPlatform.isWindows
 
-, version ? "8.11.20200731"
+, version ? "8.11.20200824"
 , # 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)
···
 
   src = fetchgit {
     url = "https://gitlab.haskell.org/ghc/ghc.git/";
-    rev = "380638a33691ba43fdcd2e18bca636750e5f66f1";
-    sha256 = "029cgiyhddvwnx5zx31i0vgj13zsvzb8fna99zr6ifscz6x7rid1";
+    rev = "3f50154591ada9064351ccec4adfe6df53ca2439";
+    sha256 = "1w2p5bc74aswspzvgvrhcb95hvj5ky38rgqqjvrri19z2qyiky6d";
   };
 
   enableParallelBuilding = true;

pkgs/development/compilers/ghcjs-ng/8.6/dep-overrides.nix

···
 { haskellLib }:
 
-let inherit (haskellLib) doJailbreak dontHaddock;
+let inherit (haskellLib) doJailbreak dontHaddock dontCheck;
 in self: super: {
+  ghcjs = super.ghcjs.override {
+    shelly = super.shelly_1_8_1;
+  };
   ghc-api-ghcjs = super.ghc-api-ghcjs.override
   {
     happy = self.happy_1_19_5;
   };
-  haddock-library-ghcjs = doJailbreak super.haddock-library-ghcjs;
+  haddock-library-ghcjs = doJailbreak (dontCheck super.haddock-library-ghcjs);
   haddock-api-ghcjs = doJailbreak (dontHaddock super.haddock-api-ghcjs);
 }

pkgs/development/compilers/ghcjs-ng/default.nix

···
 
     inherit passthru;
 
-    meta.broken = true; # build does not succeed
-    meta.platforms = lib.platforms.none;  # passthru.bootPkgs.ghc.meta.platforms;
+    meta.platforms = passthru.bootPkgs.ghc.meta.platforms;
     meta.maintainers = [lib.maintainers.elvishjerricco];
   }

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

···
   tickle = dontCheck super.tickle;
   tpdb = dontCheck super.tpdb;
   translatable-intset = dontCheck super.translatable-intset;
+  trifecta = if pkgs.stdenv.hostPlatform.isAarch64 then dontCheck super.trifecta else super.trifecta; # affected by this bug https://gitlab.haskell.org/ghc/ghc/-/issues/15275#note_295461
   ua-parser = dontCheck super.ua-parser;
   unagi-chan = dontCheck super.unagi-chan;
   wai-logger = dontCheck super.wai-logger;
···
   # Generate cli completions for dhall.
   dhall = generateOptparseApplicativeCompletion "dhall" super.dhall;
   dhall-json = generateOptparseApplicativeCompletions ["dhall-to-json" "dhall-to-yaml"] super.dhall-json;
-  dhall-nix = generateOptparseApplicativeCompletion "dhall-to-nix" (super.dhall-nix);
+  dhall-nix = generateOptparseApplicativeCompletion "dhall-to-nix" (
+    super.dhall-nix.overrideScope (self: super: {
+      dhall = super.dhall_1_34_0;
+      repline = self.repline_0_4_0_0;
+      haskeline = self.haskeline_0_8_1_0;
+    }));
 
   # https://github.com/haskell-hvr/netrc/pull/2#issuecomment-469526558
   netrc = doJailbreak super.netrc;
···
   # 2020-06-22: NOTE: QuickCheck upstreamed https://github.com/phadej/binary-instances/issues/7
   binary-instances = dontCheck super.binary-instances;
 
-  # Disabling the test suite lets the build succeed on older CPUs
-  # that are unable to run the generated library because they
-  # lack support for AES-NI, like some of our Hydra build slaves
-  # do. See https://github.com/NixOS/nixpkgs/issues/81915 for
-  # details.
-  cryptonite = dontCheck super.cryptonite;
-
   # The test suite depends on an impure cabal-install installation in
   # $HOME, which we don't have in our build sandbox.
   cabal-install-parsers = dontCheck super.cabal-install-parsers;
···
   # https://github.com/ennocramer/monad-dijkstra/issues/4
   monad-dijkstra = dontCheck (doJailbreak super.monad-dijkstra);
 
+  # Fixed upstream but not released to Hackage yet:
+  # https://github.com/k0001/hs-libsodium/issues/2
+  libsodium = overrideCabal super.libsodium (drv: {
+    libraryToolDepends = (drv.libraryToolDepends or []) ++ [self.c2hs];
+  });
+
   # https://github.com/kowainik/policeman/issues/57
   policeman = doJailbreak super.policeman;
 
···
   });
 
   # Testsuite trying to run `which haskeline-examples-Test`
-  haskeline_0_8_0_0 = dontCheck super.haskeline_0_8_0_0;
+  haskeline_0_8_1_0 = dontCheck super.haskeline_0_8_1_0;
 
   # Requires repline 0.4 which is the default only for ghc8101, override for the rest
   zre = super.zre.override {
     repline = self.repline_0_4_0_0.override {
-      haskeline = self.haskeline_0_8_0_0;
+      haskeline = self.haskeline_0_8_1_0;
     };
   };
 
···
 
   # Tests rely on `Int` being 64-bit: https://github.com/hspec/hspec/issues/431.
   # Also, we need QuickCheck-2.14.x to build the test suite, which isn't easy in LTS-16.x.
-  # So let's not go there any just disable the tests altogether.
+  # So let's not go there and just disable the tests altogether.
   hspec-core = dontCheck super.hspec-core;
 
+  # github.com/ucsd-progsys/liquidhaskell/issues/1729
+  liquidhaskell = super.liquidhaskell.override { Diff = self.Diff_0_3_4; };
+  Diff_0_3_4 = dontCheck super.Diff_0_3_4;
+
+  # We want the latest version of cryptonite. This is a first step towards
+  # resolving https://github.com/NixOS/nixpkgs/issues/81915.
+  cryptonite = self.cryptonite_0_27;
+
   # INSERT NEW OVERRIDES ABOVE THIS LINE
 
 } // (let
   hlsScopeOverride = self: super: {
     # haskell-language-server uses its own fork of ghcide
     # Test disabled: it seems to freeze (is it just that it takes a long time ?)
-    ghcide = dontCheck self.hls-ghcide;
+    ghcide = dontCheck super.hls-ghcide;
     # we are faster than stack here
-    hie-bios = dontCheck self.hie-bios_0_6_2;
-    lsp-test = dontCheck self.lsp-test_0_11_0_4;
+    hie-bios = dontCheck super.hie-bios_0_7_0;
+    lsp-test = dontCheck super.lsp-test_0_11_0_4;
     # fourmolu can‘t compile with an older aeson
     aeson = dontCheck super.aeson_1_5_2_0;
     # brittany has an aeson upper bound of 1.5
     brittany = doJailbreak super.brittany;
   };
   in {
-    haskell-language-server = dontCheck (super.haskell-language-server.overrideScope hlsScopeOverride);
+    # jailbreaking for hie-bios 0.7.0 (upstream PR: https://github.com/haskell/haskell-language-server/pull/357)
+    haskell-language-server = dontCheck (doJailbreak (super.haskell-language-server.overrideScope hlsScopeOverride));
     hls-ghcide = dontCheck (super.hls-ghcide.overrideScope hlsScopeOverride);
     fourmolu = super.fourmolu.overrideScope hlsScopeOverride;
   }

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

···
 
   # Jailbreak to fix the build.
   base-noprelude = doJailbreak super.base-noprelude;
-  pandoc = doJailbreak super.pandoc;
   system-fileio = doJailbreak super.system-fileio;
   unliftio-core = doJailbreak super.unliftio-core;
 
   # Use the latest version to fix the build.
   dhall = self.dhall_1_34_0;
   lens = self.lens_4_19_2;
+  optics = self.optics_0_3;
   optics-core = self.optics-core_0_3_0_1;
+  optics-extra = self.optics-extra_0_3;
+  optics-th = self.optics-th_0_3_0_2;
   repline = self.repline_0_4_0_0;
   singletons = self.singletons_2_7;
   th-desugar = self.th-desugar_1_11;
···
       # executable is allowed for ghc >= 8.10 and needs repline
       executableHaskellDepends = drv.executableToolDepends or [] ++ [ self.repline ];
     }));
+
+  # We want the latest version of Pandoc.
+  pandoc = self.pandoc_2_10_1;
+  pandoc-citeproc = self.pandoc-citeproc_0_17_0_2;
+  pandoc-plot = self.pandoc-plot_0_9_2_0;
+  pandoc-types = self.pandoc-types_1_21;
 
 }

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

···
 #
 # WARNING: This list is generated semiautomatically based on the most recent
 # LTS package set. If you want to add entries to it, you must do so before the
-# comment saying "# LTS Haskell x.y". Any changes after that commend will be
+# comment saying "# LTS Haskell x.y". Any changes after that comment will be
 # lost the next time `update-stackage.sh` runs.
 default-package-overrides:
   # This was only intended for ghc-7.0.4, and has very old deps, one hidden behind a flag
···
   # 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.10
+  # LTS Haskell 16.11
   - abstract-deque ==0.3
   - abstract-par ==0.3.3
   - AC-Angle ==1.0
···
   - amazonka-workspaces ==1.6.1
   - amazonka-xray ==1.6.1
   - amqp ==0.20.0
-  - amqp-utils ==0.4.4.0
+  - amqp-utils ==0.4.4.1
   - annotated-wl-pprint ==0.7.0
   - ansi-terminal ==0.10.3
   - ansi-wl-pprint ==0.6.9
···
   - attoparsec-path ==0.0.0.1
   - audacity ==0.0.2
   - aur ==7.0.3
-  - aura ==3.1.7
+  - aura ==3.1.8
   - authenticate ==1.3.5
   - authenticate-oauth ==1.6.0.1
   - auto ==0.4.3.1
···
   - bv ==0.5
   - bv-little ==1.1.1
   - byteable ==0.1.1
-  - byte-count-reader ==0.10.0.1
+  - byte-count-reader ==0.10.1.1
   - bytedump ==1.0
   - byte-order ==0.1.2.0
   - byteorder ==1.0.4
···
   - extended-reals ==0.2.4.0
   - extensible-effects ==5.0.0.1
   - extensible-exceptions ==0.1.1.4
-  - extra ==1.7.5
+  - extra ==1.7.6
   - extractable-singleton ==0.0.1
   - extrapolate ==0.4.2
   - fail ==4.9.0.0
···
   - floatshow ==0.2.4
   - flow ==1.0.21
   - flush-queue ==1.0.0
-  - fmlist ==0.9.3
+  - fmlist ==0.9.4
   - fmt ==0.6.1.2
   - fn ==0.3.0.2
   - focus ==1.0.1.3
···
   - jwt ==0.10.0
   - kan-extensions ==5.2
   - kanji ==3.4.1
-  - katip ==0.8.4.0
+  - katip ==0.8.5.0
   - kawhi ==0.3.0
   - kazura-queue ==0.1.0.4
   - kdt ==0.2.4
···
   - linux-file-extents ==0.2.0.0
   - linux-namespaces ==0.1.3.0
   - List ==0.6.2
-  - ListLike ==4.7.1
+  - ListLike ==4.7.2
   - list-predicate ==0.1.0.1
   - listsafe ==0.1.0.1
   - list-singleton ==1.0.0.4
···
   - midi ==0.2.2.2
   - mighty-metropolis ==2.0.0
   - mime-mail ==0.5.0
-  - mime-mail-ses ==0.4.1
+  - mime-mail-ses ==0.4.2
   - mime-types ==0.1.0.9
   - mini-egison ==1.0.0
   - minimal-configuration ==0.1.4
···
   - nonce ==1.0.7
   - nondeterminism ==1.4
   - non-empty ==0.3.2
-  - nonempty-containers ==0.3.4.0
+  - nonempty-containers ==0.3.4.1
   - nonemptymap ==0.0.6.0
   - non-empty-sequence ==0.2.0.4
   - nonempty-vector ==0.2.0.2
···
   - options ==1.2.1.1
   - optparse-applicative ==0.15.1.0
   - optparse-generic ==1.3.1
-  - optparse-simple ==0.1.1.2
+  - optparse-simple ==0.1.1.3
   - optparse-text ==0.1.1.0
   - ordered-containers ==0.2.2
   - ormolu ==0.1.2.0
···
   - regex-posix ==0.96.0.0
   - regex-tdfa ==1.3.1.0
   - regex-with-pcre ==1.1.0.0
-  - registry ==0.1.9.1
+  - registry ==0.1.9.3
   - reinterpret-cast ==0.1.0
   - relapse ==1.0.0.0
   - relational-query ==0.12.2.3
···
   - safe ==0.3.19
   - safecopy ==0.10.3
   - safe-decimal ==0.2.0.0
-  - safe-exceptions ==0.1.7.0
+  - safe-exceptions ==0.1.7.1
   - safe-exceptions-checked ==0.1.0
   - safe-foldable ==0.1.0.0
   - safeio ==0.0.5.0
···
   - servant-purescript ==0.10.0.0
   - servant-rawm ==0.3.2.0
   - servant-server ==0.16.2
-  - servant-static-th ==0.2.3.0
+  - servant-static-th ==0.2.4.0
   - servant-subscriber ==0.7.0.0
   - servant-swagger ==1.1.7.1
   - servant-swagger-ui ==0.3.4.3.23.11
···
   - unexceptionalio-trans ==0.5.1
   - unicode ==0.0.1.1
   - unicode-show ==0.1.0.4
-  - unicode-transforms ==0.3.6
+  - unicode-transforms ==0.3.7
   - unification-fd ==0.10.0.1
   - union-find ==0.2
   - uniplate ==1.6.12
···
   - vector-instances ==3.4
   - vector-mmap ==0.0.3
   - vector-rotcev ==0.1.0.0
-  - vector-sized ==1.4.1.0
+  - vector-sized ==1.4.2
   - vector-space ==0.16
   - vector-split ==1.0.0.2
   - vector-th-unbox ==0.2.1.7
···
   - xss-sanitize ==0.3.6
   - xturtle ==0.2.0.0
   - xxhash-ffi ==0.2.0.0
-  - yaml ==0.11.4.0
+  - yaml ==0.11.5.0
   - yamlparse-applicative ==0.1.0.1
   - yesod ==1.6.1.0
   - yesod-auth ==1.6.10
···
   - dbus <1                             # for xmonad-0.26
   - deepseq == 1.3.0.1                  # required to build Cabal with GHC 6.12.3
   - dhall == 1.29.0                     # required for spago 0.14.0.
+  - Diff < 0.4                          # required by liquidhaskell-0.8.10.2: https://github.com/ucsd-progsys/liquidhaskell/issues/1729
   - 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
+  - gi-gdk == 3.0.23                    # required for gi-pango 1.0.23
+  - gi-gtk == 3.0.35                    # required for gi-pango 1.0.23
   - gloss < 1.9.3                       # new versions don't compile with GHC 7.8.x
   - haddock == 2.22.*                   # required on GHC 8.0.x
   - haddock == 2.23.*                   # required on GHC < 8.10.x
···
   - haskell-src-exts == 1.19.*          # required by hindent and structured-haskell-mode
   - hinotify == 0.3.9                   # for xmonad-0.26: https://github.com/kolmodin/hinotify/issues/29
   - hoogle == 5.0.14                    # required by hie-hoogle
+  - hslua == 1.1.2                      # required for pandoc 2.10
   - html-conduit ^>= 1.2                # pre-lts-11.x versions neeed by git-annex 6.20180227
   - http-conduit ^>= 2.2                # pre-lts-11.x versions neeed by git-annex 6.20180227
-  - hslua == 1.1.2                      # required for pandoc 2.10
   - inline-c < 0.6                      # required on GHC 8.0.x
   - inline-c-cpp < 0.2                  # required on GHC 8.0.x
   - lens-labels == 0.1.*                # required for proto-lens-descriptors
···
   - resourcet ==1.1.*                   # pre-lts-11.x versions neeed by git-annex 6.20180227
   - seqid < 0.2                         # newer versions depend on transformers 0.4.x which we cannot provide in GHC 7.8.x
   - seqid-streams < 0.2                 # newer versions depend on transformers 0.4.x which we cannot provide in GHC 7.8.x
+  - shelly ==1.8.1                      # ghcjs depends on shelly < 1.9
   - split < 0.2                         # newer versions don't work with GHC 6.12.3
   - tar < 0.4.2.0                       # later versions don't work with GHC < 7.6.x
   - transformers == 0.4.3.*             # the latest version isn't supported by mtl yet
···
   - accelerate-examples
   - accelerate-fft
   - accelerate-fourier-benchmark
+  - accelerate-io-array
+  - accelerate-io-bmp
+  - accelerate-io-bytestring
+  - accelerate-io-cereal
+  - accelerate-io-JuicyPixels
+  - accelerate-io-repa
+  - accelerate-io-vector
   - accelerate-llvm-ptx
   - bindings-yices
   - boolector
   - ccelerate-cuda
+  - containers-accelerate
   - cplex-hs
+  - cublas
   - cuda # 2020-08-18 because of dependency nvidia-x11
-  - cublas
   - cufft
   - cusolver
   - cusparse
   - gloss-raster-accelerate
+  - hashable-accelerate
   - libnvvm
   - matlab
   - nvvm
···
   - cap
   - Capabilities
   - capability
+  - capataz
   - capnp
   - capped-list
   - capri
···
   - complexity
   - compose-trans
   - composite-aeson
+  - composite-aeson-path
   - composite-aeson-refined
-  - composite-base
+  - composite-binary
   - composite-ekg
   - composite-opaleye
   - composite-swagger
···
   - data-transform
   - data-type
   - data-util
+  - data-validation
   - data-variant
   - database-id-groundhog
   - database-study
···
   - dhall-check
   - dhall-docs
   - dhall-fly
-  - dhall-nix
   - dhall-text
   - dhall-to-cabal
   - dhall-yaml
···
   - EsounD
   - espial
   - ess
+  - essence-of-live-coding-gloss-example
+  - essence-of-live-coding-pulse-example
+  - essence-of-live-coding-warp
   - estimators
   - EstProgress
   - estreps
···
   - ghcprofview
   - ght
   - gi-cairo-again
+  - gi-cairo-connector
+  - gi-cairo-render
+  - gi-dbusmenu
+  - gi-dbusmenugtk3
+  - gi-gdkx11
+  - gi-graphene
+  - gi-gsk
+  - gi-gstpbutils
+  - gi-gsttag
+  - gi-gtk-declarative
+  - gi-gtk-declarative-app-simple
+  - gi-gtk-hs
+  - gi-gtkosxapplication
+  - gi-handy
+  - gi-poppler
+  - gi-wnck
+  - gi-xlib
   - giak
   - Gifcurry
   - ginsu
···
   - gloss-sodium
   - glpk-headers
   - glpk-hs
+  - gltf-codec
   - glue
   - GLUtil
   - gmap
···
   - haskell-src-exts-prisms
   - haskell-src-exts-qq
   - haskell-src-exts-sc
+  - haskell-src-match
   - haskell-src-meta-mwotton
   - haskell-stack-trace-plugin
   - haskell-token-utils
···
   - haskore-supercollider
   - haskore-synthesizer
   - HaskRel
+  - haskseg
   - hasktorch
   - hasktorch-codegen
   - hasktorch-ffi-th
···
   - jsonsql
   - jsontsv
   - jsonxlsx
+  - jsop
   - jspath
   - juandelacosa
   - judge
···
   - ks-test
   - KSP
   - ktx
+  - ktx-codec
   - kubernetes-client
   - kubernetes-client-core
   - kuifje
···
   - libconfig
   - libcspm
   - libexpect
+  - libfuse3
   - libGenI
   - libhbb
   - libinfluxdb
···
   - libraft
   - librandomorg
   - librato
-  - libsodium
   - libssh2
   - libssh2-conduit
   - libsystemd-daemon
···
   - lio-fs
   - lio-simple
   - lipsum-gen
-  - liquid
-  - liquid-base
-  - liquid-bytestring
-  - liquid-containers
-  - liquid-fixpoint
-  - liquid-ghc-prim
-  - liquid-parallel
-  - liquid-platform
-  - liquid-prelude
-  - liquid-vector
-  - liquidhaskell
   - liquidhaskell-cabal
   - Liquorice
   - list-fusion-probe
···
   - log4hs
   - logentries
   - logger
+  - logging-effect
   - logging-effect-extra
   - logging-effect-extra-file
   - logging-effect-extra-handler
···
   - lye
   - Lykah
   - lz4-conduit
+  - lz4-frame-conduit
   - lzma-enumerator
   - lzma-streams
   - lzo
···
   - ministg
   - minst-idx
   - mios
+  - MIP
   - mirror-tweet
   - misfortune
   - miso-action-logger
···
   - monad-atom
   - monad-atom-simple
   - monad-branch
+  - monad-classes-logging
   - monad-exception
   - monad-finally
   - monad-fork
···
   - mvc
   - mvc-updates
   - mvclient
+  - mwc-probability-transition
   - mwc-random-accelerate
   - mxnet
   - mxnet-dataiter
···
   - polydata
   - polydata-core
   - polynomial
+  - polysemy-http
   - polysemy-optics
   - polysemy-RandomFu
   - polysemy-webserver
···
   - pretty-ghci
   - pretty-ncols
   - prettyprinter-graphviz
+  - prettyprinter-lucid
   - prettyprinter-vty
   - preview
   - prim
···
   - ruler
   - ruler-core
   - rungekutta
+  - runhs
   - runmany
   - runtime-arbitrary
   - rvar
···
   - shadower
   - shake-bindist
   - shake-cabal-build
+  - shake-dhall
   - shake-extras
   - shake-minify
   - shake-pack
···
   - spanout
   - sparkle
   - sparrow
+  - spars
   - sparse
   - sparse-lin-alg
   - sparsebit
···
   - superconstraints
   - superevent
   - supermonad
+  - supernova
   - supero
   - supervisor
   - supervisors
···
   - termbox-bindings
   - terminal-text
   - termination-combinators
-  - termonad
   - termplot
   - terntup
   - terrahs
···
   - uri-parse
   - uri-template
   - uri-templater
+  - url-bytes
   - url-decoders
   - url-generic
   - URLb

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

···
        broken = true;
      }) {};
 
+  "Diff_0_3_4" = callPackage
+    ({ mkDerivation, array, base, directory, pretty, process
+     , QuickCheck, test-framework, test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "Diff";
+       version = "0.3.4";
+       sha256 = "0bqcdvhxx8dmqc3793m6axg813wv9ldz2j37f1wygbbrbbndmdvp";
+       libraryHaskellDepends = [ array base pretty ];
+       testHaskellDepends = [
+         array base directory pretty process QuickCheck test-framework
+         test-framework-quickcheck2
+       ];
+       description = "O(ND) diff algorithm in haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "Diff" = callPackage
     ({ mkDerivation, array, base, directory, pretty, process
      , QuickCheck, test-framework, test-framework-quickcheck2
···
     ({ mkDerivation, base, bytestring, HsOpenSSL, unix }:
      mkDerivation {
        pname = "HsOpenSSL-x509-system";
-       version = "0.1.0.3";
-       sha256 = "14hzjdpv8ld3nw5fcx451w49vq0s8fhs1zh984vpm85b5ypbgp2v";
+       version = "0.1.0.4";
+       sha256 = "15mp70bqg1lzp971bzp6wym3bwzvxb76hzbgckygbfa722xyymhr";
        libraryHaskellDepends = [ base bytestring HsOpenSSL unix ];
        description = "Use the system's native CA certificate store with HsOpenSSL";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "ListLike";
-       version = "4.7.1";
-       sha256 = "1gccb84fma0plkwjdz8hgqa70a5lr6d9gnw6pfky993555ig29mp";
-       libraryHaskellDepends = [
-         array base bytestring containers deepseq dlist fmlist text
-         utf8-string vector
-       ];
-       testHaskellDepends = [
-         array base bytestring containers dlist fmlist HUnit QuickCheck
-         random text utf8-string vector
-       ];
-       description = "Generalized support for list-like structures";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "ListLike_4_7_2" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, deepseq
-     , dlist, fmlist, HUnit, QuickCheck, random, text, utf8-string
-     , vector
-     }:
-     mkDerivation {
-       pname = "ListLike";
        version = "4.7.2";
        sha256 = "15c1q4rl4kwpgpsdf4x7k17m2fgzimm9915k71cpjiv0sq9b2rn2";
        libraryHaskellDepends = [
···
        ];
        description = "Generalized support for list-like structures";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "ListT" = callPackage
···
        ];
        description = "Library for using Mixed Integer Programming (MIP)";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "MSQueue" = callPackage
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "MapWith";
-       version = "0.1.0.0";
-       sha256 = "1dk5b9bi29917sf3mk3q85iqjkfc7vczwb8x8cg6w6gxfqn0444v";
-       revision = "1";
-       editedCabalFile = "1zkpqgxh2d1zg087766vixw5j9xh9i9z4vdp5gv87xzhc4ig9qbs";
+       version = "0.2.0.0";
+       sha256 = "1xkyaj83yblf42qawv4nyi8miaynydd8b3ysx62f9y10bqxk7dja";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        benchmarkHaskellDepends = [ base ];
-       description = "mapWith: like fmap, but with additional arguments (isFirst, isLast, etc)";
+       description = "mapWith: like fmap, but with additional parameters (isFirst, isLast, etc)";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "VulkanMemoryAllocator";
-       version = "0.3.6";
-       sha256 = "1zclpawaa1cx1p58asn7lla4lakkr869qnkdvrypxxqki3406hsz";
+       version = "0.3.7";
+       sha256 = "1y2dmk60dvk8d9n16in98cmin5ckvdx3knwlfzcs0jl6vyh8n51n";
        libraryHaskellDepends = [
          base bytestring transformers vector vulkan
        ];
···
          inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXinerama; 
          inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXrender;};
 
+  "X11_1_9_2" = callPackage
+    ({ mkDerivation, base, data-default, libX11, libXext, libXinerama
+     , libXrandr, libXrender, libXScrnSaver
+     }:
+     mkDerivation {
+       pname = "X11";
+       version = "1.9.2";
+       sha256 = "013yny4dwbs98kp7245j8dv81h4p1cdwn2rsf2hvhsplg6ixkc05";
+       libraryHaskellDepends = [ base data-default ];
+       librarySystemDepends = [
+         libX11 libXext libXinerama libXrandr libXrender libXScrnSaver
+       ];
+       description = "A binding to the X11 graphics library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXScrnSaver; 
+         inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXinerama; 
+         inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXrender;};
+
   "X11-extras" = callPackage
     ({ mkDerivation, base, libX11, X11 }:
      mkDerivation {
···
      }) {};
 
   "accelerate" = callPackage
-    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, base-orphans
-     , bytestring, Cabal, cabal-doctest, constraints, containers
-     , cryptonite, deepseq, directory, doctest, exceptions, filepath
-     , ghc-prim, half, hashable, hashtables, hedgehog, lens, mtl, tasty
-     , tasty-expected-failure, tasty-hedgehog, tasty-hunit
-     , template-haskell, terminal-size, transformers, unique, unix
+    ({ mkDerivation, ansi-terminal, base, base-orphans, bytestring
+     , Cabal, cabal-doctest, containers, cryptonite, deepseq, directory
+     , doctest, exceptions, filepath, ghc-prim, half, hashable
+     , hashtables, hedgehog, lens, mtl, prettyprinter
+     , prettyprinter-ansi-terminal, primitive, tasty, template-haskell
+     , terminal-size, text, transformers, unique, unix
      , unordered-containers, vector
      }:
      mkDerivation {
        pname = "accelerate";
-       version = "1.2.0.1";
-       sha256 = "0vglmasqgq0h8fvm9z8l2b3sygqvix8vr6c3n357gkr2mpz6gq8h";
+       version = "1.3.0.0";
+       sha256 = "14md9fbxckgwpbkm7hdj95ny11w5b5cj103r8razg0aw2hgid5sb";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
-         ansi-terminal ansi-wl-pprint base base-orphans bytestring
-         constraints containers cryptonite deepseq directory exceptions
-         filepath ghc-prim half hashable hashtables hedgehog lens mtl tasty
-         tasty-expected-failure tasty-hedgehog tasty-hunit template-haskell
-         terminal-size transformers unique unix unordered-containers vector
+         ansi-terminal base base-orphans bytestring containers cryptonite
+         deepseq directory exceptions filepath ghc-prim half hashable
+         hashtables hedgehog lens mtl prettyprinter
+         prettyprinter-ansi-terminal primitive tasty template-haskell
+         terminal-size text transformers unique unix unordered-containers
+         vector
        ];
        testHaskellDepends = [ base doctest ];
        description = "An embedded language for accelerated array processing";
···
      }) {};
 
   "accelerate-bignum" = callPackage
-    ({ mkDerivation, accelerate, accelerate-io, accelerate-llvm
+    ({ mkDerivation, accelerate, accelerate-io-vector, accelerate-llvm
      , accelerate-llvm-native, accelerate-llvm-ptx, base, criterion
      , ghc-prim, hedgehog, llvm-hs-pure, mwc-random, tasty
      , tasty-hedgehog, template-haskell, vector, vector-th-unbox
···
      }:
      mkDerivation {
        pname = "accelerate-bignum";
-       version = "0.2.0.0";
-       sha256 = "0xhnd39fb17kb7q5z9z8svn8zlv6j1wxrbkv3vij4f1q2hkqkl0p";
-       revision = "1";
-       editedCabalFile = "0lfsmhky8shyy9xhm0j2as91vrmqqrrn9r0fsv2ljc4xjklg723r";
+       version = "0.3.0.0";
+       sha256 = "1xwqg3d2qilkfx8wmmhp2qq5cas3pnsrpyli3a9z0yxqamibxh33";
        libraryHaskellDepends = [
          accelerate accelerate-llvm accelerate-llvm-native
          accelerate-llvm-ptx base ghc-prim llvm-hs-pure template-haskell
···
          tasty tasty-hedgehog
        ];
        benchmarkHaskellDepends = [
-         accelerate accelerate-io accelerate-llvm-native accelerate-llvm-ptx
-         base criterion mwc-random vector vector-th-unbox wide-word
+         accelerate accelerate-io-vector accelerate-llvm-native
+         accelerate-llvm-ptx base criterion mwc-random vector
+         vector-th-unbox wide-word
        ];
        description = "Fixed-length large integer arithmetic for Accelerate";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "accelerate-blas";
-       version = "0.2.0.1";
-       sha256 = "00869y2zrh43sl0rap8bbgnzqdvrrxpc2qhzz0zdfasr3440py6k";
+       version = "0.3.0.0";
+       sha256 = "1ydym6fxvg1b5vx49r8dnn80spsq42ssbg4v01s1djklks054g7y";
        libraryHaskellDepends = [
          accelerate accelerate-llvm accelerate-llvm-native
          accelerate-llvm-ptx base blas-hs bytestring containers cublas cuda
···
 
   "accelerate-examples" = callPackage
     ({ mkDerivation, accelerate, accelerate-fft, accelerate-io
-     , accelerate-llvm-native, accelerate-llvm-ptx, ansi-wl-pprint, base
-     , binary, bmp, bytestring, bytestring-lexing, cereal
+     , accelerate-io-bmp, accelerate-io-repa, accelerate-io-vector
+     , accelerate-llvm-native, accelerate-llvm-ptx, ansi-wl-pprint
+     , array, base, binary, bmp, bytestring, bytestring-lexing, cereal
      , colour-accelerate, containers, criterion, criterion-measurement
      , directory, fclabels, filepath, gloss, gloss-accelerate
      , gloss-raster-accelerate, gloss-rendering, HUnit, lens-accelerate
-     , linear, linear-accelerate, matrix-market-attoparsec, mwc-random
-     , normaldistribution, QuickCheck, random, repa, repa-io, scientific
-     , test-framework, test-framework-hunit, test-framework-quickcheck2
-     , vector, vector-algorithms
+     , linear-accelerate, matrix-market-attoparsec, mwc-random
+     , mwc-random-accelerate, normaldistribution, QuickCheck, random
+     , repa, repa-io, scientific, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, vector, vector-algorithms
      }:
      mkDerivation {
        pname = "accelerate-examples";
-       version = "1.2.0.1";
-       sha256 = "0hzk6zas03yhh8xjjrh772knhbvisl0r6q10y4mcq552bcfd8yvj";
+       version = "1.3.0.0";
+       sha256 = "145m2bi8bini6z2jg6g99vnsc3m7pqz4dc9l34j8fg40fw65rwi0";
        configureFlags = [ "-f-opencl" ];
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          accelerate accelerate-llvm-native accelerate-llvm-ptx
          ansi-wl-pprint base containers criterion directory fclabels HUnit
-         linear mwc-random QuickCheck test-framework test-framework-hunit
+         QuickCheck test-framework test-framework-hunit
          test-framework-quickcheck2
        ];
        executableHaskellDepends = [
-         accelerate accelerate-fft accelerate-io base binary bmp bytestring
-         bytestring-lexing cereal colour-accelerate containers criterion
-         criterion-measurement directory fclabels filepath gloss
+         accelerate accelerate-fft accelerate-io accelerate-io-bmp
+         accelerate-io-repa accelerate-io-vector array base binary bmp
+         bytestring bytestring-lexing cereal colour-accelerate containers
+         criterion criterion-measurement directory fclabels filepath gloss
          gloss-accelerate gloss-raster-accelerate gloss-rendering
          lens-accelerate linear-accelerate matrix-market-attoparsec
-         mwc-random normaldistribution random repa repa-io scientific vector
-         vector-algorithms
+         mwc-random mwc-random-accelerate normaldistribution random repa
+         repa-io scientific vector vector-algorithms
        ];
        description = "Examples using the Accelerate library";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "accelerate-fft";
-       version = "1.2.0.0";
-       sha256 = "19p9d59vdd3nq97xjprlb6fz2ajlk6gl37cdyvrm9inag4nnk6lp";
-       revision = "2";
-       editedCabalFile = "096vhbwbkyvjx8znjqnb3lz43kzqq0x7kcfv1gmmbjjrcmwaj2y5";
+       version = "1.3.0.0";
+       sha256 = "1a7cwzbs8r3rvaymrq2kfx83lqb3i7wz0gmz3ppz59f40rxn974x";
        libraryHaskellDepends = [
          accelerate accelerate-llvm accelerate-llvm-native
          accelerate-llvm-ptx base bytestring carray containers cuda cufft
···
      }) {};
 
   "accelerate-io" = callPackage
-    ({ mkDerivation, accelerate, array, base, bmp, bytestring, hedgehog
-     , primitive, repa, tasty, tasty-hedgehog, vector
+    ({ mkDerivation, accelerate, base }:
+     mkDerivation {
+       pname = "accelerate-io";
+       version = "1.3.0.0";
+       sha256 = "048md40pfacxa1mbzncybxzwp9fzmsaq8i94pd8ai677n2zyw5cg";
+       libraryHaskellDepends = [ accelerate base ];
+       description = "Convert between Accelerate arrays and raw pointers";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "accelerate-io-JuicyPixels" = callPackage
+    ({ mkDerivation, accelerate, accelerate-io-vector, base
+     , JuicyPixels, vector
      }:
      mkDerivation {
-       pname = "accelerate-io";
-       version = "1.2.0.0";
-       sha256 = "13pqqsd5pbxmgsxnp9w141mnwscnlmbhxaz6f5jx4ssipnma2pwf";
-       revision = "2";
-       editedCabalFile = "0w8y40p71c6c7cj49n4kanwmsa53s2nydigiiidqp93yxhw0virq";
+       pname = "accelerate-io-JuicyPixels";
+       version = "0.1.0.0";
+       sha256 = "0rr43lwmc16r99si1s4nimxxydlsxb6ck45absrxy6vnkln7x185";
        libraryHaskellDepends = [
-         accelerate array base bmp bytestring primitive repa vector
+         accelerate accelerate-io-vector base JuicyPixels vector
        ];
+       description = "Convert between Accelerate arrays and JuicyPixels images";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "accelerate-io-array" = callPackage
+    ({ mkDerivation, accelerate, array, base, hedgehog, primitive
+     , tasty, tasty-hedgehog
+     }:
+     mkDerivation {
+       pname = "accelerate-io-array";
+       version = "0.1.0.0";
+       sha256 = "1gcxd4m3h1xr8ia8z7c8sxznm90h2q3mzwhi5vsv8s1gh7sdym9m";
+       libraryHaskellDepends = [ accelerate array base primitive ];
        testHaskellDepends = [
-         accelerate array base hedgehog tasty tasty-hedgehog vector
+         accelerate array base hedgehog tasty tasty-hedgehog
+       ];
+       description = "Convert between Accelerate and array";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "accelerate-io-bmp" = callPackage
+    ({ mkDerivation, accelerate, accelerate-io-bytestring, base, bmp }:
+     mkDerivation {
+       pname = "accelerate-io-bmp";
+       version = "0.1.0.0";
+       sha256 = "0x7bkn4j7s9dzlfk4q1lh6fyd4bir1zkm4x37c65nl9g86154sc8";
+       libraryHaskellDepends = [
+         accelerate accelerate-io-bytestring base bmp
+       ];
+       description = "Convert between Accelerate arrays and BMP images";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "accelerate-io-bytestring" = callPackage
+    ({ mkDerivation, accelerate, base, bytestring }:
+     mkDerivation {
+       pname = "accelerate-io-bytestring";
+       version = "0.1.0.0";
+       sha256 = "15j42ahdcqpy4xbpp1xibfbjcrijy0hpfxp4k53qkb9bcqaknyq1";
+       libraryHaskellDepends = [ accelerate base bytestring ];
+       description = "Convert between Accelerate and ByteString";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "accelerate-io-cereal" = callPackage
+    ({ mkDerivation, accelerate, accelerate-io-bytestring, base, cereal
+     }:
+     mkDerivation {
+       pname = "accelerate-io-cereal";
+       version = "0.1.0.0";
+       sha256 = "13im1kmrd2yjxxrmpzp2030jhhq9fm9xa76yl11xwpd82z10a2pl";
+       libraryHaskellDepends = [
+         accelerate accelerate-io-bytestring base cereal
+       ];
+       description = "Binary serialisation of Accelerate arrays using cereal";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "accelerate-io-repa" = callPackage
+    ({ mkDerivation, accelerate, base, repa }:
+     mkDerivation {
+       pname = "accelerate-io-repa";
+       version = "0.1.0.0";
+       sha256 = "084gzvfwz6prwra5393lfm5hgvssxwij0cdf24fq5nahzn7x2wrp";
+       libraryHaskellDepends = [ accelerate base repa ];
+       description = "Convert between Accelerate and Repa arrays";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "accelerate-io-vector" = callPackage
+    ({ mkDerivation, accelerate, base, hedgehog, primitive, tasty
+     , tasty-hedgehog, vector
+     }:
+     mkDerivation {
+       pname = "accelerate-io-vector";
+       version = "0.1.0.0";
+       sha256 = "1nh7n3qj4csxyzvkhkvfr9bii2vmqky51f32pz3bphrwfvhzdrri";
+       libraryHaskellDepends = [ accelerate base primitive vector ];
+       testHaskellDepends = [
+         accelerate base hedgehog tasty tasty-hedgehog vector
        ];
-       description = "Read and write Accelerate arrays in various formats";
+       description = "Convert between Accelerate and vector";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "accelerate-kullback-liebler" = callPackage
···
      }) {};
 
   "accelerate-llvm" = callPackage
-    ({ mkDerivation, abstract-deque, accelerate, base, bytestring
-     , chaselev-deque, containers, data-default-class, deepseq
-     , directory, dlist, exceptions, filepath, llvm-hs, llvm-hs-pure
-     , mtl, mwc-random, primitive, template-haskell
-     , unordered-containers, vector
+    ({ mkDerivation, accelerate, base, bytestring, constraints
+     , containers, data-default-class, deepseq, directory, dlist
+     , exceptions, filepath, llvm-hs, llvm-hs-pure, mtl, primitive
+     , template-haskell, unordered-containers, vector
      }:
      mkDerivation {
        pname = "accelerate-llvm";
-       version = "1.2.0.1";
-       sha256 = "1cv5s7fgkdd3m95vy2rrq2kvzyzxx6vwgsc5nqcmfdp00z8znjhk";
+       version = "1.3.0.0";
+       sha256 = "1fjjfjav11s6grwl6ihqdrzx738bwki0l25qlp4zzz2hi2440qbp";
        libraryHaskellDepends = [
-         abstract-deque accelerate base bytestring chaselev-deque containers
+         accelerate base bytestring constraints containers
          data-default-class deepseq directory dlist exceptions filepath
-         llvm-hs llvm-hs-pure mtl mwc-random primitive template-haskell
+         llvm-hs llvm-hs-pure mtl primitive template-haskell
          unordered-containers vector
        ];
        description = "Accelerate backend component generating LLVM IR";
···
 
   "accelerate-llvm-native" = callPackage
     ({ mkDerivation, accelerate, accelerate-llvm, base, bytestring
-     , c2hs, Cabal, cereal, containers, directory, dlist, filepath, ghc
-     , ghc-prim, hashable, libffi, llvm-hs, llvm-hs-pure, lockfree-queue
-     , mtl, template-haskell, time, unique, unix, vector
+     , c2hs, cereal, containers, deepseq, directory, dlist, filepath
+     , ghc, ghc-prim, hashable, libffi, llvm-hs, llvm-hs-pure
+     , lockfree-queue, mtl, template-haskell, unique, unix, vector
      }:
      mkDerivation {
        pname = "accelerate-llvm-native";
-       version = "1.2.0.1";
-       sha256 = "0sml5rj3dnxlv14i4xbs1sadnprjga1iws7fl7sxkyjzxqc04vrj";
+       version = "1.3.0.0";
+       sha256 = "1x4wfbp83ppzknd98k2ad160a8kdqh96qqmyfzdqyvy44iskxcn6";
        libraryHaskellDepends = [
-         accelerate accelerate-llvm base bytestring Cabal cereal containers
-         directory dlist filepath ghc ghc-prim hashable libffi llvm-hs
-         llvm-hs-pure lockfree-queue mtl template-haskell time unique unix
-         vector
+         accelerate accelerate-llvm base bytestring cereal containers
+         deepseq directory dlist filepath ghc ghc-prim hashable libffi
+         llvm-hs llvm-hs-pure lockfree-queue mtl template-haskell unique
+         unix vector
        ];
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [ accelerate base ];
···
   "accelerate-llvm-ptx" = callPackage
     ({ mkDerivation, accelerate, accelerate-llvm, base, bytestring
      , containers, cuda, deepseq, directory, dlist, file-embed, filepath
-     , hashable, llvm-hs, llvm-hs-pure, mtl, nvvm, pretty, process
-     , template-haskell, time, unordered-containers
+     , ghc-heap, hashable, llvm-hs, llvm-hs-pure, mtl, nvvm, pretty
+     , process, template-haskell, unordered-containers
      }:
      mkDerivation {
        pname = "accelerate-llvm-ptx";
-       version = "1.2.0.1";
-       sha256 = "0c9hl19v4si0lnah4l63kqhpxz16zy0wi3cg28gz00mxzgqilivs";
+       version = "1.3.0.0";
+       sha256 = "0bb7p67dv5csbblnaxbm7hkq8y2qknz0yd1f0rav29igsv3a9rfx";
        libraryHaskellDepends = [
          accelerate accelerate-llvm base bytestring containers cuda deepseq
-         directory dlist file-embed filepath hashable llvm-hs llvm-hs-pure
-         mtl nvvm pretty process template-haskell time unordered-containers
+         directory dlist file-embed filepath ghc-heap hashable llvm-hs
+         llvm-hs-pure mtl nvvm pretty process template-haskell
+         unordered-containers
        ];
        testHaskellDepends = [ accelerate base ];
        description = "Accelerate backend for NVIDIA GPUs";
···
      }:
      mkDerivation {
        pname = "amqp-utils";
-       version = "0.4.4.0";
-       sha256 = "07zpmq9sx6lmnma4dxxph0jficghrlfbb568frh3d6fbdiqgmfgl";
-       isLibrary = false;
-       isExecutable = true;
-       executableHaskellDepends = [
-         amqp base bytestring connection containers data-default-class
-         directory hinotify magic network process text time tls unix
-         utf8-string x509-system
-       ];
-       description = "Generic Haskell AMQP tools";
-       license = stdenv.lib.licenses.gpl3;
-     }) {};
-
-  "amqp-utils_0_4_4_1" = callPackage
-    ({ mkDerivation, amqp, base, bytestring, connection, containers
-     , data-default-class, directory, hinotify, magic, network, process
-     , text, time, tls, unix, utf8-string, x509-system
-     }:
-     mkDerivation {
-       pname = "amqp-utils";
        version = "0.4.4.1";
        sha256 = "1vs0p7pc6z9mfjd2vns66wnhl8v1n9rbgabyjw0v832m2pwizzmj";
        isLibrary = false;
···
        ];
        description = "AMQP toolset for the command line";
        license = stdenv.lib.licenses.gpl3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "amqp-worker" = callPackage
···
      }:
      mkDerivation {
        pname = "archive-libarchive";
-       version = "1.0.0.0";
-       sha256 = "0pqq76gnk6y71c5wwjhq99y2695v6bfyzjb8gakp6h3jivcpd2gb";
-       revision = "1";
-       editedCabalFile = "12wq8nisyr2i1861v2377llha63nqpiys9vk6dvg9rfz7f6qqdch";
+       version = "1.0.0.1";
+       sha256 = "079wm4c9bahvi693g6655ag9rz9l5g7i4b82q7zm0hz383f94zsl";
        libraryHaskellDepends = [
          base bytestring composition-prelude libarchive
        ];
···
      }:
      mkDerivation {
        pname = "aura";
-       version = "3.1.7";
-       sha256 = "0w7m65bh38gdq186b16pcnq7k2nakiy749m7z092cv4k5w72gal5";
-       revision = "1";
-       editedCabalFile = "1g8hm1bd4yssmy1qkarnwd8w2wz8c2m02gk1agh3pyv60f9q66s7";
+       version = "3.1.8";
+       sha256 = "19zm9bwpixqdg4a5mcrv2c8fyhygjzawjrwv1jwwhcczqsrjwvrw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "autoapply";
-       version = "0.4";
-       sha256 = "0b7la51399kcj9a4z9j49xd9v2zs172vygs3djz5qid7fsl37pgm";
+       version = "0.4.1";
+       sha256 = "1jgzfdi5p0pns6w7543yp2ljglnmym9qplyb4vafynzg3bjhzvz0";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base logict mtl template-haskell th-desugar transformers
···
        pname = "base64-bytestring-type";
        version = "1.0.1";
        sha256 = "03kq4rjj6by02rf3hg815jfdqpdk0xygm5f46r2pn8mb99yd01zn";
-       revision = "6";
-       editedCabalFile = "05z53pc1gi62lzl262mc1qx12qqrds6ab6rflwpfcxbp0a67c825";
+       revision = "7";
+       editedCabalFile = "1vry5qh9w1adwyfrlx8x2772knwmdvxgq2nfzng7vybll2cqph4c";
        libraryHaskellDepends = [
          aeson base base-compat base64-bytestring binary bytestring cereal
          deepseq hashable http-api-data QuickCheck serialise text
···
      }:
      mkDerivation {
        pname = "byte-count-reader";
-       version = "0.10.0.1";
-       sha256 = "0ibckpy0wz2f8590z92lvkmwcf29lv6sby1y3cz3cihxvp3bw3il";
-       libraryHaskellDepends = [ base extra parsec parsec-numbers text ];
-       testHaskellDepends = [
-         base extra hspec parsec parsec-numbers text
-       ];
-       description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB";
-       license = stdenv.lib.licenses.gpl3;
-     }) {};
-
-  "byte-count-reader_0_10_1_1" = callPackage
-    ({ mkDerivation, base, extra, hspec, parsec, parsec-numbers, text
-     }:
-     mkDerivation {
-       pname = "byte-count-reader";
        version = "0.10.1.1";
        sha256 = "0amzhcy60rmiyfp7cgdg7g1xcf7z5zz43kg18i1bwwj565ipb6p8";
        libraryHaskellDepends = [ base extra parsec parsec-numbers text ];
···
        ];
        description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB";
        license = stdenv.lib.licenses.gpl3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "byte-order" = callPackage
···
        pname = "cabal-plan";
        version = "0.7.0.0";
        sha256 = "1wv375dq50fibzg6xa9vrr8q4lhaqcl254b9a2vc42rrjvhxxmzc";
-       revision = "1";
-       editedCabalFile = "0gc64mgk11nszilkbid351zxh5cpy85kqcc3mrkrw2fsbcga08as";
+       revision = "2";
+       editedCabalFile = "1c3w9d75kqxhyafjyl8fyzbrp80idvhd693rsd08gws8blkk1vzr";
        configureFlags = [ "-fexe" ];
        isLibrary = true;
        isExecutable = true;
···
        ];
        description = "OTP-like supervision trees in Haskell";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "capnp" = callPackage
···
     ({ mkDerivation, accelerate, base }:
      mkDerivation {
        pname = "colour-accelerate";
-       version = "0.3.0.0";
-       sha256 = "0zvzra2w0sajw0hzg2k25khv8c5j1i17g8dnga70w73f3mmh3gbz";
-       revision = "1";
-       editedCabalFile = "1mbz9wdx396q8gdy6yqsc5vsxrkky9zkxczjblvc9zy542v252cn";
+       version = "0.4.0.0";
+       sha256 = "1j7ff2wb58yf346z2abr1v1yq498fxm498rdf1g62ppf6vkdplw8";
        libraryHaskellDepends = [ accelerate base ];
        description = "Working with colours in Accelerate";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "composite-aeson";
-       version = "0.7.3.0";
-       sha256 = "0wb15vq95kf6jigfy0n3jampnx8xmkxmh2lnxgfsc8zac9hwls55";
+       version = "0.7.4.0";
+       sha256 = "1k8m89cff8b3yc1af0l9vd13pav2hjy51gcadahn07zpwv1bszfj";
        libraryHaskellDepends = [
          aeson aeson-better-errors base composite-base containers
          contravariant generic-deriving hashable lens mmorph mtl profunctors
···
        broken = true;
      }) {};
 
+  "composite-aeson-path" = callPackage
+    ({ mkDerivation, base, composite-aeson, path }:
+     mkDerivation {
+       pname = "composite-aeson-path";
+       version = "0.7.4.0";
+       sha256 = "08p988iq7y76px61dlj5jq35drmnrf4khi27wpqgh3pg9d96yihx";
+       libraryHaskellDepends = [ base composite-aeson path ];
+       description = "Formatting data for the path library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "composite-aeson-refined" = callPackage
     ({ mkDerivation, aeson-better-errors, base, composite-aeson, mtl
      , refined
      }:
      mkDerivation {
        pname = "composite-aeson-refined";
-       version = "0.7.3.0";
-       sha256 = "0g0i8zwky1ygniyxpvgl1r78b4qak1mx1wpy2pj815zrd43x1y60";
+       version = "0.7.4.0";
+       sha256 = "049lrm5iip5y3c9m9x4sjangaigdprj1553sw2vrcvnvn8xfq57s";
        libraryHaskellDepends = [
          aeson-better-errors base composite-aeson mtl refined
        ];
···
      }) {};
 
   "composite-base" = callPackage
-    ({ mkDerivation, base, exceptions, hspec, lens, monad-control, mtl
-     , profunctors, QuickCheck, template-haskell, text, transformers
-     , transformers-base, unliftio-core, vinyl
+    ({ mkDerivation, base, deepseq, exceptions, hspec, lens
+     , monad-control, mtl, profunctors, QuickCheck, template-haskell
+     , text, transformers, transformers-base, unliftio-core, vinyl
      }:
      mkDerivation {
        pname = "composite-base";
-       version = "0.7.3.0";
-       sha256 = "07zbs89cqm7b78jfh2lwma3spsklc6wq0f58g14p27wgm253xkwp";
+       version = "0.7.4.0";
+       sha256 = "1ml1y1zh8znvaqydwcnv8n69rzmx7zy2bpzr65gy79xbczz3dxwz";
        libraryHaskellDepends = [
-         base exceptions lens monad-control mtl profunctors template-haskell
-         text transformers transformers-base unliftio-core vinyl
-       ];
-       testHaskellDepends = [
-         base exceptions hspec lens monad-control mtl profunctors QuickCheck
+         base deepseq exceptions lens monad-control mtl profunctors
          template-haskell text transformers transformers-base unliftio-core
          vinyl
+       ];
+       testHaskellDepends = [
+         base deepseq exceptions hspec lens monad-control mtl profunctors
+         QuickCheck template-haskell text transformers transformers-base
+         unliftio-core vinyl
        ];
        description = "Shared utilities for composite-* packages";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "composite-binary" = callPackage
+    ({ mkDerivation, base, binary, composite-base }:
+     mkDerivation {
+       pname = "composite-binary";
+       version = "0.7.4.0";
+       sha256 = "07d88krkpplprnw57j4bqi71p8bmj0wz28yw41wgl2p5g2h7zccp";
+       libraryHaskellDepends = [ base binary composite-base ];
+       description = "Orphan binary instances";
+       license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "composite-ekg";
-       version = "0.7.3.0";
-       sha256 = "1402ay8gxqp1fh2ija9ry5g366p5vx64ikmfal9hr2c42c2kmcf9";
+       version = "0.7.4.0";
+       sha256 = "0y8wnp6n1fvqfrkm1lqv8pdfq7a4k7gaxl3i9dh6xfzyamlghg82";
        libraryHaskellDepends = [
          base composite-base ekg-core lens text vinyl
        ];
···
        broken = true;
      }) {};
 
+  "composite-hashable" = callPackage
+    ({ mkDerivation, base, composite-base, hashable }:
+     mkDerivation {
+       pname = "composite-hashable";
+       version = "0.7.4.0";
+       sha256 = "0zwv6m9nzz0g3ngmfznxh6wmprhcgdbfxrsgylnr6990ppk0bmg1";
+       libraryHaskellDepends = [ base composite-base hashable ];
+       description = "Orphan hashable instances";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "composite-opaleye" = callPackage
     ({ mkDerivation, base, bytestring, composite-base, hspec, lens
      , opaleye, postgresql-simple, product-profunctors, profunctors
···
      }:
      mkDerivation {
        pname = "composite-opaleye";
-       version = "0.7.3.0";
-       sha256 = "0b9h0z4v0268qgcwq53p59nkwbbg77dqm9snr4zif71xhmlfscpx";
+       version = "0.7.4.0";
+       sha256 = "0nzyslqgh7m9ryqw4rajq2m4kfknqzdq0aqnygyz0sblmgixn4hm";
        libraryHaskellDepends = [
          base bytestring composite-base lens opaleye postgresql-simple
          product-profunctors profunctors template-haskell text vinyl
···
      }:
      mkDerivation {
        pname = "composite-swagger";
-       version = "0.7.3.0";
-       sha256 = "1gzmksq2dfywird7gyjc95v3spgxsab3jbakg5il2fmkx35cc1za";
+       version = "0.7.4.0";
+       sha256 = "0a7pcs06m0w0mq60y3hhgn4a36gx5daypc1nh1ndsm6x3q3d99q8";
        libraryHaskellDepends = [
          base composite-base insert-ordered-containers lens swagger2
          template-haskell text vinyl
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "containers-accelerate" = callPackage
+    ({ mkDerivation, accelerate, accelerate-llvm-native, base
+     , containers, half, hashable-accelerate, hedgehog, tasty
+     , tasty-hedgehog
+     }:
+     mkDerivation {
+       pname = "containers-accelerate";
+       version = "0.1.0.0";
+       sha256 = "1bfw5k6nq15szgwjkzd17inmlk0ii0pd6a4lrixi8gyjf6ksm6n1";
+       libraryHaskellDepends = [ accelerate base hashable-accelerate ];
+       testHaskellDepends = [
+         accelerate accelerate-llvm-native base containers half
+         hashable-accelerate hedgehog tasty tasty-hedgehog
+       ];
+       description = "Hashing-based container types";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "containers-benchmark" = callPackage
     ({ mkDerivation, base, bytestring, containers, criterion, deepseq
      , ghc-prim, random
···
        ];
        description = "Extras for the \"contravariant\" package";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "contravariant-extras_0_3_5_2" = callPackage
+    ({ mkDerivation, base, contravariant, template-haskell
+     , template-haskell-compat-v0208
+     }:
+     mkDerivation {
+       pname = "contravariant-extras";
+       version = "0.3.5.2";
+       sha256 = "0ikwzg0992j870yp0x2ssf4mv2hw2nml979apg493m72xnvr1jz9";
+       libraryHaskellDepends = [
+         base contravariant template-haskell template-haskell-compat-v0208
+       ];
+       description = "Extras for the \"contravariant\" package";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "control" = callPackage
···
      }:
      mkDerivation {
        pname = "cublas";
-       version = "0.5.0.0";
-       sha256 = "0s47wrmlb35dpym4dz3688qx8m166i2a9d8pqnfdzxy67zv98g1f";
+       version = "0.6.0.0";
+       sha256 = "0yxyynvf9zlkc8yhra5j1sk1d8hbiqvzbsh02mc1y8hcf8nzyp61";
        setupHaskellDepends = [ base Cabal cuda directory filepath ];
        libraryHaskellDepends = [
          base cuda half storable-complex template-haskell
···
      }:
      mkDerivation {
        pname = "cuda";
-       version = "0.10.1.0";
-       sha256 = "10lyyc652ic3m4r5agszpv2r99y9fnsdwahb5pd4qiga770v45vp";
-       revision = "2";
-       editedCabalFile = "1nw135pd2ab3mmyq3xmkxynzfb54qr7a8xssq5ivrk83yzvs87im";
+       version = "0.10.2.0";
+       sha256 = "0fkjibnnxradhsbasx1mw0c088cfwypnk6a5002rxpzxid5qrp9l";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal directory filepath ];
···
      }:
      mkDerivation {
        pname = "cufft";
-       version = "0.9.0.1";
-       sha256 = "1cf11ia4i19bpbs0wzkz2hqzc22hh2dvbn8m5frnwild83zal4n3";
+       version = "0.10.0.0";
+       sha256 = "1prma5srgfnhjvf1rvxd1kznv42k4svhk05j93mx1pcx7jd1cmvz";
        setupHaskellDepends = [
          base Cabal cuda directory filepath template-haskell
        ];
···
      }:
      mkDerivation {
        pname = "cusolver";
-       version = "0.2.0.0";
-       sha256 = "0v30wm32jcz7jy940y26zcqvjy1058bqf0v44xf73v53dlwkd07a";
+       version = "0.3.0.0";
+       sha256 = "0xskvpjqlckpfrfvnb2afj29p2gnzafq2v98pbvwsprmn60np9mq";
        setupHaskellDepends = [ base Cabal cuda directory filepath ];
        libraryHaskellDepends = [
          base cublas cuda cusparse half storable-complex template-haskell
···
      }:
      mkDerivation {
        pname = "cusparse";
-       version = "0.2.0.0";
-       sha256 = "1y6qnxfdcw3ik3mjp4410846pq1l628d02bdasll1xd4r4r87vh6";
+       version = "0.3.0.0";
+       sha256 = "0x2ab7sd7j1mmjns8332mm2nzikprq3w6fbrnbcfk5lz2x0bgir2";
        setupHaskellDepends = [ base Cabal cuda directory filepath ];
        libraryHaskellDepends = [ base cuda half storable-complex ];
        libraryToolDepends = [ c2hs ];
···
        broken = true;
      }) {};
 
+  "data-validation" = callPackage
+    ({ mkDerivation, base, containers, hspec, template-haskell }:
+     mkDerivation {
+       pname = "data-validation";
+       version = "0.1.0.1";
+       sha256 = "0bc3i4pnz1v516cmsnay1hpmh9r7zglwyv2ai1ncxy2k4l78pih0";
+       libraryHaskellDepends = [ base containers template-haskell ];
+       testHaskellDepends = [ base containers hspec template-haskell ];
+       description = "A library for creating type safe validations";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "data-variant" = callPackage
     ({ mkDerivation, base, safe }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "dataflower";
-       version = "0.2.2.0";
-       sha256 = "169m0yngaslc2pysdpf65pmf9zr037ij7y95rqi6bp3dxcxfcwlg";
+       version = "0.3.0.0";
+       sha256 = "0nxir4syhbw5spqks3pxj71w781vn8mqxdiig9dqnrv5ks02bqp6";
        libraryHaskellDepends = [
          base hashable mtl pretty-show stm time transformers vector
        ];
···
        ];
        description = "Dhall to Nix compiler";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "dhall-nixpkgs" = callPackage
···
      }) {};
 
   "dobutokO-poetry" = callPackage
-    ({ mkDerivation, base, dobutokO-poetry-general, mmsyn3, mmsyn6ukr
-     , mmsyn7s, uniqueness-periods, vector
+    ({ mkDerivation, base, dobutokO-poetry-general, mmsyn2, mmsyn3
+     , mmsyn5, mmsyn6ukr, mmsyn7s, uniqueness-periods, vector
      }:
      mkDerivation {
        pname = "dobutokO-poetry";
-       version = "0.15.0.0";
-       sha256 = "1091wqxzg138bc8kk55fkgv5ripq48zyvm3in2b2g54zjy6l4f1p";
+       version = "0.16.3.0";
+       sha256 = "151ncvk2jz2nlgr52485p6mdqix7qlld96kzi9y3hxag2kpb0723";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base dobutokO-poetry-general mmsyn3 mmsyn6ukr mmsyn7s
+         base dobutokO-poetry-general mmsyn2 mmsyn3 mmsyn5 mmsyn6ukr mmsyn7s
          uniqueness-periods vector
        ];
        executableHaskellDepends = [
-         base dobutokO-poetry-general mmsyn3 mmsyn6ukr mmsyn7s
+         base dobutokO-poetry-general mmsyn2 mmsyn3 mmsyn5 mmsyn6ukr mmsyn7s
          uniqueness-periods vector
        ];
        description = "Helps to order the 7 or less Ukrainian words to obtain somewhat suitable for poetry or music text";
···
      }:
      mkDerivation {
        pname = "dom-lt";
-       version = "0.2.1";
-       sha256 = "16pf0lzzg0wwk5q44ybbc2hbrjs5hzsai0ssm836xiywsqwp61a7";
+       version = "0.2.2";
+       sha256 = "0hf0wf4fl671awf87f0r7r4a57cgm88x666081c0wy16qchahffw";
        libraryHaskellDepends = [ array base containers ];
        testHaskellDepends = [ base containers HUnit ];
        benchmarkHaskellDepends = [ base containers criterion deepseq ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "essence-of-live-coding_0_2_2" = callPackage
+  "essence-of-live-coding_0_2_3" = callPackage
     ({ mkDerivation, base, containers, foreign-store, mtl, QuickCheck
-     , syb, test-framework, test-framework-quickcheck2, transformers
-     , vector-sized
+     , syb, test-framework, test-framework-quickcheck2, time
+     , transformers, vector-sized
      }:
      mkDerivation {
        pname = "essence-of-live-coding";
-       version = "0.2.2";
-       sha256 = "1hczvr1byk8qjkb45w9nvjmbqfmxl15dgn7kvp0rby0dkrn85275";
+       version = "0.2.3";
+       sha256 = "19sc5wgby356bm5rh7sr41ydhw3v1pqbz76xyf7081kg77qcbc0m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers foreign-store syb transformers vector-sized
+         base containers foreign-store syb time transformers vector-sized
        ];
        executableHaskellDepends = [ base transformers ];
        testHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "essence-of-live-coding-gloss_0_2_2" = callPackage
+  "essence-of-live-coding-gloss_0_2_3" = callPackage
     ({ mkDerivation, base, essence-of-live-coding, foreign-store, gloss
      , syb, transformers
      }:
      mkDerivation {
        pname = "essence-of-live-coding-gloss";
-       version = "0.2.2";
-       sha256 = "19kxrjyhikgb49qdb7rlap8bbjsvkyi2ni6a1m1hjyxjziypsw0y";
+       version = "0.2.3";
+       sha256 = "0msc2pfg7096azk4ggb267cfm2vh02kcksgdmzl46rc5if98xmi7";
        libraryHaskellDepends = [
          base essence-of-live-coding foreign-store gloss syb transformers
        ];
···
      }:
      mkDerivation {
        pname = "essence-of-live-coding-gloss-example";
-       version = "0.2.2";
-       sha256 = "07kgmbwm9swdavsypxnqf64fh9b2c2h9rmkm38hcl6lahdb2rb44";
+       version = "0.2.3";
+       sha256 = "08hzfi3mspxlkbhh8mr1q330yp94s6s9w55pla7x10qj8vda4shc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "General purpose live coding framework - Gloss example";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "essence-of-live-coding-pulse" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "essence-of-live-coding-pulse_0_2_2" = callPackage
+  "essence-of-live-coding-pulse_0_2_3" = callPackage
     ({ mkDerivation, base, essence-of-live-coding, foreign-store
      , pulse-simple, transformers
      }:
      mkDerivation {
        pname = "essence-of-live-coding-pulse";
-       version = "0.2.2";
-       sha256 = "15v4bzkx4j6mvprk1d215ywamjjvmf6g13cppd109aj4h40zcxbi";
+       version = "0.2.3";
+       sha256 = "1mxgicmy5xmmad0r0b3dn18ab9dn8r3rqglqxa6v75kl8lswm0c8";
        libraryHaskellDepends = [
          base essence-of-live-coding foreign-store pulse-simple transformers
        ];
···
      }:
      mkDerivation {
        pname = "essence-of-live-coding-pulse-example";
-       version = "0.2.2";
-       sha256 = "1476wxny2yhq2f2cn2bqrcm4dri39mql509pf9yq2kyd76lkrcgx";
+       version = "0.2.3";
+       sha256 = "0da3l6z0lnjlq62vx18s2jyvrydffxvcjhv2ydlwczrcy0wggdln";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "General purpose live coding framework - pulse backend example";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "essence-of-live-coding-quickcheck" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "essence-of-live-coding-quickcheck_0_2_2" = callPackage
+  "essence-of-live-coding-quickcheck_0_2_3" = callPackage
     ({ mkDerivation, base, boltzmann-samplers, essence-of-live-coding
      , QuickCheck, syb, transformers
      }:
      mkDerivation {
        pname = "essence-of-live-coding-quickcheck";
-       version = "0.2.2";
-       sha256 = "1v7ijzs64bqn8nyp1msrrvk6kfkzx5a87ib74fmcasiww1y4lwgl";
+       version = "0.2.3";
+       sha256 = "0shbpc1ivqr3m9p76kf1vj7g1rqy3magxyh58w1mxymf4c61a9gr";
        libraryHaskellDepends = [
          base boltzmann-samplers essence-of-live-coding QuickCheck syb
          transformers
···
      }:
      mkDerivation {
        pname = "essence-of-live-coding-warp";
-       version = "0.2.2";
-       sha256 = "14ygm62ak6gprx0r545xmv5nk544p0gsip3017p7ziy3k01mwhgh";
+       version = "0.2.3";
+       sha256 = "1rpp6xm3s3fji1pcdajc06iw0zhk3mbd245h6a0z6ygf8id7sh50";
        libraryHaskellDepends = [
          base essence-of-live-coding http-types wai warp
        ];
        testHaskellDepends = [ base essence-of-live-coding http-client ];
        description = "General purpose live coding framework";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "estimator" = callPackage
···
      }:
      mkDerivation {
        pname = "extra";
-       version = "1.7.5";
-       sha256 = "1cickrjvg4i25yn3qg4f0id0bmq115siysyqnh0yk9rwjlnrxyn9";
+       version = "1.7.6";
+       sha256 = "1mdqw88crblabxz4sg803ww6pkl5prnjnpjwh11n32y2npky5ask";
        libraryHaskellDepends = [
          base clock directory filepath process time unix
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "extra_1_7_7" = callPackage
+    ({ mkDerivation, base, clock, directory, filepath, process
+     , QuickCheck, quickcheck-instances, time, unix
+     }:
+     mkDerivation {
+       pname = "extra";
+         semigroups tfp transformers unique-logic-tf utility-ht
+       sha256 = "1ark7b6xknc44v8jg5aymxffj5d0qr81frjpg2ffqrkwnhva0w5s";
+       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
···
      }:
      mkDerivation {
        pname = "filestore";
-       version = "0.6.4";
-       sha256 = "1z967kviqsy3ma8xdfffx864f7ji6nsrbd5riis0nasm1bbwm8rr";
-       enableSeparateDataOutput = true;
+       version = "0.6.5";
+       sha256 = "0z29273vdqjsrj4vby0gp7d12wg9nkzq9zgqg18db0p5948jw1dh";
        libraryHaskellDepends = [
          base bytestring containers Diff directory filepath old-locale
          parsec process split time utf8-string xml
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "fmlist";
-       version = "0.9.3";
-       sha256 = "1w9nhm2zybdx4c1lalkajwqr8wcs731lfjld2r8gknd7y96x8pwf";
-       libraryHaskellDepends = [ base ];
-       description = "FoldMap lists";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "fmlist_0_9_4" = callPackage
-    ({ mkDerivation, base }:
-     mkDerivation {
-       pname = "fmlist";
        version = "0.9.4";
        sha256 = "19h95ph7lh7llw6j1v1rssrdi5k7xw8x0iac9rgzss371s2w3g9d";
        libraryHaskellDepends = [ base ];
        description = "FoldMap lists";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "fmt" = callPackage
···
      }:
      mkDerivation {
        pname = "functor-combinators";
-       version = "0.3.5.1";
-       sha256 = "07hwsy8nly4sps3fsyfmq54cwfb850j1i1darwsyw24ignbd60j4";
+       version = "0.3.6.0";
+       sha256 = "0idf896xadp5v5k4m0s087xvvs9008sxw61djqb9v0x08rs5zy8f";
        libraryHaskellDepends = [
          assoc base bifunctors comonad constraints containers contravariant
          deriving-compat free invariant kan-extensions mmorph mtl
···
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.16.3";
-       sha256 = "0y9g7nldcx2y7h3gb652i5r3lfvbriaqfqs2gnxym1r9w9kki0si";
+       version = "0.16.4";
+       sha256 = "14k682phqdp2scmv064i6jyymf3j2f3bs25yw1qff76bkymv02vd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "generic-functor" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "generic-functor";
+       version = "0.1.0.0";
+       sha256 = "02anlx3l0zn4hx9pckpdpp93yp1xyqcafpy6rk7s1zpv7nqk12z2";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "Deriving generalized functors with GHC.Generics";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "generic-lens" = callPackage
     ({ mkDerivation, base, doctest, generic-lens-core, HUnit
      , inspection-testing, lens, profunctors, text
···
        broken = true;
      }) {};
 
+  "generic-match" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "generic-match";
+       version = "0.2.0.2";
+       sha256 = "16r43gzl3a8ycxbhggqk09mrm63r9db85nk1j2x4j4lzcwap7bid";
+       libraryHaskellDepends = [ base ];
+       description = "First class pattern matching";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "generic-maybe" = callPackage
     ({ mkDerivation, base, bytestring, containers, criterion, deepseq
      , directory, doctest, filepath, generic-deriving, ghc-prim, hlint
···
        ];
        description = "GI friendly Binding to the Cairo library";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gi-cairo-render" = callPackage
···
        libraryToolDepends = [ c2hs ];
        description = "GI friendly Binding to the Cairo library";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) cairo;};
 
   "gi-dbusmenu" = callPackage
···
        libraryPkgconfigDepends = [ libdbusmenu ];
        description = "Dbusmenu bindings";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) libdbusmenu;};
 
   "gi-dbusmenu_0_4_8" = callPackage
···
        description = "Dbusmenu bindings";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) libdbusmenu;};
 
   "gi-dbusmenugtk3" = callPackage
···
        libraryPkgconfigDepends = [ gtk3 libdbusmenu-gtk3 ];
        description = "DbusmenuGtk bindings";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gtk3; inherit (pkgs) libdbusmenu-gtk3;};
 
   "gi-dbusmenugtk3_0_4_9" = callPackage
···
        description = "DbusmenuGtk bindings";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gtk3; inherit (pkgs) libdbusmenu-gtk3;};
 
   "gi-gdk" = callPackage
···
        libraryPkgconfigDepends = [ gtk3 ];
        description = "GdkX11 bindings";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gtk3;};
 
   "gi-gdkx11_4_0_2" = callPackage
···
        description = "GdkX11 bindings";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {gtk4-x11 = null;};
 
   "gi-ggit" = 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-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
···
        ];
        description = "Declarative GTK+ programming in Haskell";
        license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gi-gtk-declarative-app-simple" = callPackage
···
        ];
        description = "Declarative GTK+ programming in Haskell in the style of Pux";
        license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gi-gtk-hs" = callPackage
···
        ];
        description = "A wrapper for gi-gtk, adding a few more idiomatic API parts on top";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gi-gtk-hs_0_3_9" = callPackage
···
        description = "A wrapper for gi-gtk, adding a few more idiomatic API parts on top";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gi-gtkosxapplication" = callPackage
···
        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 = [ libhandy ];
        description = "libhandy bindings";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) libhandy;};
 
   "gi-harfbuzz" = 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 = [ libwnck ];
        description = "Wnck bindings";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) libwnck;};
 
   "gi-xlib" = callPackage
···
        libraryPkgconfigDepends = [ xlibsWrapper ];
        description = "xlib bindings";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) xlibsWrapper;};
 
   "gi-xlib_2_0_9" = callPackage
···
        description = "xlib bindings";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) xlibsWrapper;};
 
   "giak" = callPackage
···
        ];
        description = "An implementation of the Jinja2 template language in Haskell";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "ginger_0_10_1_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring
+     , data-default, filepath, http-types, mtl, optparse-applicative
+     , parsec, process, regex-tdfa, safe, scientific, tasty, tasty-hunit
+     , tasty-quickcheck, text, time, transformers, unordered-containers
+     , utf8-string, vector, yaml
+     }:
+     mkDerivation {
+       pname = "ginger";
+       version = "0.10.1.0";
+       sha256 = "0579ajr1rng0bd0pml69f6yz4aykvk8zcni0p7ck628qx4jzxihx";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring data-default filepath http-types
+         mtl parsec regex-tdfa safe scientific text time transformers
+         unordered-containers utf8-string vector
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring data-default optparse-applicative process
+         text transformers unordered-containers utf8-string yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring data-default mtl tasty tasty-hunit
+         tasty-quickcheck text time transformers unordered-containers
+         utf8-string
+       ];
+       description = "An implementation of the Jinja2 template language in Haskell";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "gingersnap" = callPackage
···
      }) {};
 
   "gloss-accelerate" = callPackage
-    ({ mkDerivation, accelerate, base, gloss, gloss-rendering }:
+    ({ mkDerivation, accelerate, base, gloss, gloss-rendering
+     , linear-accelerate
+     }:
      mkDerivation {
        pname = "gloss-accelerate";
-       version = "2.0.0.1";
-       sha256 = "106z8kax0m3hzk0381l8m7gxdapl3wf0fdr1ljwb5fgcjc00pac2";
-       revision = "1";
-       editedCabalFile = "0349yyzxn7r82mz4vr71dibzp0sh45b4a06hm0c0z9d7vlxj0sjj";
-       libraryHaskellDepends = [ accelerate base gloss gloss-rendering ];
+       version = "2.1.0.0";
+       sha256 = "1l09li68r04qij11p7rf9dwfv9cdncj7nm6crq6bm834il3zg4zx";
+       libraryHaskellDepends = [
+         accelerate base gloss gloss-rendering linear-accelerate
+       ];
        description = "Extras to interface Gloss and Accelerate";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "gloss-raster-accelerate";
-       version = "2.0.0.0";
-       sha256 = "1i0qx9wybr66i1x4n3p8ai2z6qx0k5lac422mhh4rvimcjx2bc9d";
-       revision = "3";
-       editedCabalFile = "0nk901zy01x7v7faa20j0yawqfw3nfl27xr19ip7bn3agmq4sqq2";
+       version = "2.1.0.0";
+       sha256 = "0yxlpz5wqfriijzkhqgjyv3g0wcmdy33ifbziqrdm9phvsjygvza";
        libraryHaskellDepends = [
          accelerate base colour-accelerate gloss gloss-accelerate
        ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) glpk;};
+
+  "gltf-codec" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring
+     , directory, filepath, scientific, shower, text
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "gltf-codec";
+       version = "0.1.0.1";
+       sha256 = "0qdwk4ygvhdp4x8bkw101b50wc8zfb6bb54zpxaxkmva40hcv2c2";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring binary bytestring scientific text
+         unordered-containers vector
+       ];
+       testHaskellDepends = [ base bytestring directory filepath shower ];
+       description = "glTF scene loader";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
 
   "glue" = callPackage
     ({ mkDerivation, async, base, ekg-core, hashable, hspec
···
        ];
        description = "GraphQL API";
        license = stdenv.lib.licenses.asl20;
+     }) {};
+
+  "graphql-client" = callPackage
+    ({ mkDerivation, aeson, aeson-schemas, base, bytestring, file-embed
+     , http-client, http-client-tls, http-types, mtl
+     , optparse-applicative, path, path-io, tasty, tasty-hunit
+     , template-haskell, text, transformers, typed-process
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "graphql-client";
+       version = "1.0.0";
+       sha256 = "1qzrlk3vkvavi14zz7dkndz8qh449s6rpbrd5phqclgbrah1hj3a";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-schemas base http-client http-client-tls http-types mtl
+         template-haskell text transformers unliftio-core
+       ];
+       executableHaskellDepends = [
+         aeson aeson-schemas base bytestring file-embed http-client
+         http-client-tls http-types mtl optparse-applicative path path-io
+         template-haskell text transformers typed-process unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson aeson-schemas base http-client http-client-tls http-types mtl
+         tasty tasty-hunit template-haskell text transformers unliftio-core
+       ];
+       description = "A client for Haskell programs to query a GraphQL API";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "graphql-w-persistent" = callPackage
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
+  "happy_1_20_0" = callPackage
+    ({ mkDerivation, array, base, containers, mtl, process }:
+     mkDerivation {
+       pname = "happy";
+       version = "1.20.0";
+       sha256 = "1346r2x5ravs5fqma65bzjragqbb2g6v41wz9maknwm2jf7kl79v";
+       isLibrary = false;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       executableHaskellDepends = [ array base containers mtl ];
+       testHaskellDepends = [ base process ];
+       description = "Happy is a parser generator for Haskell";
+       license = stdenv.lib.licenses.bsd2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "happy-dot" = callPackage
     ({ mkDerivation, array, base, clock, happy, HUnit, language-dot
      , pretty, transformers, xml
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hashable-accelerate" = callPackage
+    ({ mkDerivation, accelerate, base, template-haskell }:
+     mkDerivation {
+       pname = "hashable-accelerate";
+       version = "0.1.0.0";
+       sha256 = "04cfwd1vyz4xm87ah3x1avs2yzqi6ygcd3sl70v50g492dfl6738";
+       libraryHaskellDepends = [ accelerate base template-haskell ];
+       description = "A class for types which can be converted into a hash value";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hashable-extras" = callPackage
     ({ mkDerivation, base, bifunctors, bytestring, directory, doctest
      , filepath, hashable, transformers, transformers-compat
···
        libraryHaskellDepends = [ base containers deepseq hashable ];
        description = "Persistent containers Map and Set based on hashing";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "hashmap-throw" = callPackage
+    ({ mkDerivation, base, exceptions, hashable, hashmap }:
+     mkDerivation {
+       pname = "hashmap-throw";
+       version = "0.1.0.0";
+       sha256 = "0dibdmpb6nyhn37xfdw8wgam4a2w8b3hl04ivg08d1ybq4a4m1k5";
+       libraryHaskellDepends = [ base exceptions hashable hashmap ];
+       description = "Throw behaviour for hashmap lookup";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "hashrename" = callPackage
···
        broken = true;
      }) {};
 
-  "haskeline_0_8_0_0" = callPackage
+  "haskeline_0_8_1_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory
      , exceptions, filepath, HUnit, process, stm, terminfo, text
      , transformers, unix
      }:
      mkDerivation {
        pname = "haskeline";
-       version = "0.8.0.0";
-       sha256 = "0gqsa5s0drim9m42hv4wrq61mnvcdylxysfxfw3acncwilfrn9pb";
+       version = "0.8.1.0";
+       sha256 = "0r6skxr45k0qq5vlh9dyl5g5ham994b8z0k3z3v56bi3npvyi6xw";
        configureFlags = [ "-fterminfo" ];
        isLibrary = true;
        isExecutable = true;
···
        pname = "haskell-src";
        version = "1.0.3.1";
        sha256 = "0cjigvshk4b8wqdk0v0hz9ag1kyjjsmqsy4a1m3n28ac008cg746";
+       revision = "1";
+       editedCabalFile = "1li6czcs54wnij6qnvpx6f66iiw023pggb3zl3jvp74qqflcf5sg";
        libraryHaskellDepends = [ array base pretty syb ];
        libraryToolDepends = [ happy ];
        description = "Support for manipulating Haskell source code";
···
        ];
        description = "Helper functions for working with haskell-src-exts trees";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "haskell-src-match" = callPackage
+    ({ mkDerivation, base, containers, filepath, haskell-src-exts
+     , hspec, interpolatedstring-perl6, pretty-simple, split
+     , template-haskell, text, transformers
+     }:
+     mkDerivation {
+       pname = "haskell-src-match";
+       version = "0.0.0.1";
+       sha256 = "0lhdnmzmwxsiw0if600apdvmkbqz44zwr7sypfclixl9c6h31wg0";
+       libraryHaskellDepends = [
+         base containers haskell-src-exts interpolatedstring-perl6
+         pretty-simple split template-haskell transformers
+       ];
+       testHaskellDepends = [
+         base filepath hspec interpolatedstring-perl6 template-haskell text
+       ];
+       description = "Testing code generators piece by piece";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "haskell-src-meta" = callPackage
···
        ];
        description = "Simple unsupervised segmentation model";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "hasktags" = callPackage
···
      }:
      mkDerivation {
        pname = "hercules-ci-agent";
-       version = "0.7.3";
-       sha256 = "19mz8cqrk7v49h8k2bcpv31qnplx7r10k010gzcwmhhfyrlyrqyg";
+       version = "0.7.4";
+       sha256 = "0yj9njd168xpj4har99mbb9rr5dqsbnzqs1061s3czrzlp229z3l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "hie-bios_0_6_2" = callPackage
+  "hie-bios_0_7_0" = 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.2";
-       sha256 = "0x0lgrkbp4f9r96cf65d8qg55hp2qb14xd3zzap5yhybhlp54w8m";
+       version = "0.7.0";
+       sha256 = "17jfiyxq1m0n1i9a565niczivkkxdd36l9gxqbhfafxsykggliab";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "http-api-data_0_4_2" = callPackage
+    ({ mkDerivation, attoparsec, attoparsec-iso8601, base, base-compat
+     , bytestring, containers, cookie, hashable, hspec, hspec-discover
+     , http-types, HUnit, nats, QuickCheck, quickcheck-instances, tagged
+     , text, time-compat, transformers, unordered-containers, uuid-types
+     }:
+     mkDerivation {
+       pname = "http-api-data";
+       version = "0.4.2";
+       sha256 = "0xzfvxxh33ivlnrnzmm19cni3jgb5ph18n9hykkw3d6l3rhwzcnl";
+       libraryHaskellDepends = [
+         attoparsec attoparsec-iso8601 base base-compat bytestring
+         containers cookie hashable http-types tagged text time-compat
+         transformers unordered-containers uuid-types
+       ];
+       testHaskellDepends = [
+         base base-compat bytestring cookie hspec HUnit nats QuickCheck
+         quickcheck-instances text time-compat unordered-containers
+         uuid-types
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Converting to/from HTTP API data like URL pieces, headers and query parameters";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "http-attoparsec" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, http-types }:
      mkDerivation {
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "http-client_0_7_2" = callPackage
+  "http-client_0_7_2_1" = callPackage
     ({ mkDerivation, array, async, base, blaze-builder, bytestring
      , case-insensitive, containers, cookie, deepseq, directory
      , exceptions, filepath, ghc-prim, hspec, http-types, memory
···
      }:
      mkDerivation {
        pname = "http-client";
-       version = "0.7.2";
-       sha256 = "1ld8bx1bnf1gpvdy9wn14b31k94rjvl40zqrgd7nb20zd2l354vp";
+       version = "0.7.2.1";
+       sha256 = "0b699f07yqa525xqqcs4cn32fryjc2212sv8v83yfqlqwdwzr7jg";
        libraryHaskellDepends = [
          array base blaze-builder bytestring case-insensitive containers
          cookie deepseq exceptions filepath ghc-prim http-types memory
···
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
+  "http-link-header_1_1_1" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, criterion, directory
+     , errors, hspec, hspec-attoparsec, http-api-data, network-uri
+     , QuickCheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "http-link-header";
+       version = "1.1.1";
+       sha256 = "0bgffcmdswmpw3gl2yricz56y0cxb4x8l0j0qs60c6h16rcp5xwh";
+       libraryHaskellDepends = [
+         attoparsec base bytestring errors http-api-data network-uri text
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring errors hspec hspec-attoparsec
+         http-api-data network-uri QuickCheck text
+       ];
+       benchmarkHaskellDepends = [
+         attoparsec base bytestring criterion directory errors http-api-data
+         network-uri text transformers
+       ];
+       description = "A parser and writer for the HTTP Link header per RFC 5988";
+       license = stdenv.lib.licenses.publicDomain;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "http-listen" = callPackage
     ({ mkDerivation, base, bytestring, exceptions, HTTP, network
      , transformers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "ihaskell_0_10_1_2" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring, cereal
+     , cmdargs, containers, directory, filepath, ghc, ghc-boot
+     , ghc-parser, ghc-paths, haskeline, haskell-src-exts, here, hlint
+     , hspec, hspec-contrib, http-client, http-client-tls, HUnit
+     , ipython-kernel, mtl, parsec, process, random, raw-strings-qq
+     , setenv, shelly, split, stm, strict, text, time, transformers
+     , unix, unordered-containers, utf8-string, vector
+     }:
+     mkDerivation {
+       pname = "ihaskell";
+       version = "0.10.1.2";
+       sha256 = "1gs2j0qgxzf346nlnq0zx12yj528ykxia5r3rlldpf6f01zs89v8";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base base64-bytestring bytestring cereal cmdargs containers
+         directory filepath ghc ghc-boot ghc-parser ghc-paths haskeline
+         haskell-src-exts hlint http-client http-client-tls ipython-kernel
+         mtl parsec process random shelly split stm strict text time
+         transformers unix unordered-containers utf8-string vector
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring containers directory ghc ipython-kernel
+         process strict text transformers unix unordered-containers
+       ];
+       testHaskellDepends = [
+         base directory ghc ghc-paths here hspec hspec-contrib HUnit
+         raw-strings-qq setenv shelly text transformers
+       ];
+       description = "A Haskell backend kernel for the IPython project";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "ihaskell-aeson" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, here
      , ihaskell, text
···
      }) {};
 
   "indigo" = callPackage
-    ({ mkDerivation, base, constraints, containers, fmt, hedgehog
-     , hspec-expectations, HUnit, lorentz, morley, morley-prelude
-     , reflection, singletons, tasty, tasty-discover, tasty-hedgehog
-     , tasty-hunit-compat, template-haskell, vinyl
+    ({ mkDerivation, base, cleveland, constraints, containers, fmt
+     , hedgehog, hspec-expectations, HUnit, lorentz, morley
+     , morley-prelude, reflection, singletons, tasty, tasty-discover
+     , tasty-hedgehog, tasty-hunit-compat, template-haskell, vinyl
      }:
      mkDerivation {
        pname = "indigo";
-       version = "0.1.0.0";
-       sha256 = "03bspqbw8iz25d58xvy18qzk7wrm5k48k6bvnnslkikqy2bnkcr1";
+       version = "0.2.0";
+       sha256 = "070ha5s8yirci7zdnh8gy8hdh158zsj7z7blwsr7inw753fsh1jp";
        libraryHaskellDepends = [
          base constraints containers lorentz morley morley-prelude
          reflection singletons template-haskell vinyl
        ];
        testHaskellDepends = [
-         base containers fmt hedgehog hspec-expectations HUnit lorentz
-         morley morley-prelude singletons tasty tasty-hedgehog
+         base cleveland containers fmt hedgehog hspec-expectations HUnit
+         lorentz morley morley-prelude singletons tasty tasty-hedgehog
          tasty-hunit-compat
        ];
        testToolDepends = [ tasty-discover ];
···
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
-     }) {};
+     }) {cleveland = null;};
 
   "inf-interval" = callPackage
     ({ mkDerivation, array, base, deepseq, QuickCheck, text, vector }:
···
     ({ mkDerivation, base, containers, text, vector, word8 }:
      mkDerivation {
        pname = "intmap-graph";
-       version = "1.1.0.0";
-       sha256 = "0yg88vvq53kbzw2r8i1w1g4am4bkp8qzgy9qsc7wknb3zwlzs89w";
+       version = "1.3.0.0";
+       sha256 = "0g4kf7d4yh29jlb5a2f8awjbmaan2f7m1ybkcihayp83lvjld4v0";
        libraryHaskellDepends = [ base containers text vector word8 ];
        description = "A graph library that allows to explore edges after their type";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "intro_0_8_0_0" = callPackage
+  "intro_0_9_0_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, extra, hashable
      , lens, mtl, optics, QuickCheck, safe, text, transformers
      , unordered-containers, writer-cps-mtl
      }:
      mkDerivation {
        pname = "intro";
-       version = "0.8.0.0";
-       sha256 = "1vmhmpcikxlmad2c55bdlsa7j1x30irjb7dp69qii650qslh2rf3";
+       version = "0.9.0.0";
+       sha256 = "0x48bj9nri2zhsjpwx08nvjmpsjq6zd61npa02zsf357wylxir0x";
        libraryHaskellDepends = [
          base bytestring containers extra hashable mtl safe text
          transformers unordered-containers writer-cps-mtl
···
        ];
        description = "A library for creating kernels for IPython frontends";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "ipython-kernel_0_10_2_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, cereal, cereal-text
+     , containers, cryptonite, directory, filepath, memory, mtl, parsec
+     , process, temporary, text, transformers, unordered-containers
+     , uuid, zeromq4-haskell
+     }:
+     mkDerivation {
+       pname = "ipython-kernel";
+       version = "0.10.2.1";
+       sha256 = "016w7bmji3k1cnnl3vq35zq6fnqdvc2x762zfzv4ync2jz63rq38";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base bytestring cereal cereal-text containers cryptonite
+         directory filepath memory mtl parsec process temporary text
+         transformers unordered-containers uuid zeromq4-haskell
+       ];
+       description = "A library for creating kernels for IPython frontends";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "irc" = callPackage
···
     ({ mkDerivation, base, binary, ixset-typed }:
      mkDerivation {
        pname = "ixset-typed-binary-instance";
-       version = "0.1.0.0";
-       sha256 = "1qa00y5cn3i2b66h87i6sfx6xx4yvgq7gk6maij5b9w4c821h4m4";
+       version = "0.1.0.2";
+       sha256 = "1jgqc1ys5pvfkha8pyddz5f01qsmv9a83xw0q75njk8zhqajlyvx";
        libraryHaskellDepends = [ base binary ixset-typed ];
        description = "Binary instance for ixset-typed";
        license = stdenv.lib.licenses.mit;
···
     ({ mkDerivation, base, hashable, ixset-typed }:
      mkDerivation {
        pname = "ixset-typed-hashable-instance";
-       version = "0.1.0.1";
-       sha256 = "14cd3kzhqv8w9f756drhjpmrr32i6n9sjmp9fk2gngsigaksnvnk";
+       version = "0.1.0.2";
+       sha256 = "0bwajqlj1kpis2616lrmcymmag66fkmdrsrj0r3kf8j6090zxmyv";
        libraryHaskellDepends = [ base hashable ixset-typed ];
        description = "Hashable instance for ixset-typed";
        license = stdenv.lib.licenses.mit;
···
   "jsop" = callPackage
     ({ mkDerivation, aeson, base, containers, generics-sop, lens
      , lens-aeson, monoidal-containers, protolude, string-interpolate
-     , tasty, tasty-discover, tasty-hspec, text
+     , tasty, tasty-discover, tasty-hspec, text, unordered-containers
      }:
      mkDerivation {
        pname = "jsop";
-       version = "0.1.0.0";
-       sha256 = "0yaxcpxgn00jf3igvncg59ca6hz28sf791872n617v3vh7arv8y3";
+       version = "0.2.0.1";
+       sha256 = "05qacp69pk4fm1b1mrk2ax8f8mbfzsb71bkj2qraa116xym61j38";
        libraryHaskellDepends = [
          aeson base containers generics-sop lens lens-aeson
          monoidal-containers protolude string-interpolate tasty
-         tasty-discover tasty-hspec text
+         tasty-discover tasty-hspec text unordered-containers
        ];
        testHaskellDepends = [
          aeson base containers generics-sop lens lens-aeson
          monoidal-containers protolude string-interpolate tasty
-         tasty-discover tasty-hspec text
+         tasty-discover tasty-hspec text unordered-containers
        ];
        testToolDepends = [ tasty-discover ];
        description = "Cherry picking in JSON objects";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "jspath" = callPackage
···
      }) {};
 
   "juicy-gcode" = callPackage
-    ({ mkDerivation, base, configurator, lens, linear, matrix
+    ({ mkDerivation, base, configurator, gitrev, lens, linear, matrix
      , optparse-applicative, svg-tree, text
      }:
      mkDerivation {
        pname = "juicy-gcode";
-       version = "0.1.0.10";
-       sha256 = "17ps1kkbjvlvyjzbqagwikw960nn8q4dzjvng0waknr2gaa125bj";
+       version = "0.2.0.1";
+       sha256 = "1jpdxxfg3wdj9kz41a1pklyshrxxakf2bahcc7y1l7p7jklb3lbi";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base configurator lens linear matrix optparse-applicative svg-tree
-         text
+         base configurator gitrev lens linear matrix optparse-applicative
+         svg-tree text
        ];
        description = "SVG to G-Code converter";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "katip";
-       version = "0.8.4.0";
-       sha256 = "0hkhvkdyk4m5pdr0yj1lbdwqvrfr7sq49jw683mk0lxjlyc39xm6";
-       libraryHaskellDepends = [
-         aeson async auto-update base bytestring containers either hostname
-         microlens microlens-th monad-control mtl old-locale resourcet
-         safe-exceptions scientific semigroups stm string-conv
-         template-haskell text time transformers transformers-base
-         transformers-compat unix unliftio-core unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers directory microlens
-         quickcheck-instances regex-tdfa safe-exceptions stm tasty
-         tasty-golden tasty-hunit tasty-quickcheck template-haskell text
-         time time-locale-compat unordered-containers
-       ];
-       benchmarkHaskellDepends = [
-         aeson async base blaze-builder criterion deepseq directory filepath
-         safe-exceptions text time transformers unix
-       ];
-       description = "A structured logging framework";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "katip_0_8_5_0" = callPackage
-    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
-     , bytestring, containers, criterion, deepseq, directory, either
-     , filepath, hostname, microlens, microlens-th, monad-control, mtl
-     , old-locale, quickcheck-instances, regex-tdfa, resourcet
-     , safe-exceptions, scientific, semigroups, stm, string-conv, tasty
-     , tasty-golden, tasty-hunit, tasty-quickcheck, template-haskell
-     , text, time, time-locale-compat, transformers, transformers-base
-     , transformers-compat, unix, unliftio-core, unordered-containers
-     }:
-     mkDerivation {
-       pname = "katip";
        version = "0.8.5.0";
        sha256 = "1kjzsx4fqbknnv158ypg5jhmw7ww1rk1mf99g3dci09xg97wmgjk";
        libraryHaskellDepends = [
···
        ];
        description = "A structured logging framework";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "katip-datadog" = callPackage
···
        broken = true;
      }) {egl = null; inherit (pkgs) glew;};
 
+  "ktx-codec" = callPackage
+    ({ mkDerivation, base, binary, bytestring, containers, directory
+     , filepath, shower, text, vector
+     }:
+     mkDerivation {
+       pname = "ktx-codec";
+       version = "0.0.1.1";
+       sha256 = "1qvkcmxilvlwsbp5pidkh3njwsj6k19ybz8jw5mcm90zdhx3gya0";
+       libraryHaskellDepends = [
+         base binary bytestring containers text vector
+       ];
+       testHaskellDepends = [
+         base binary bytestring containers directory filepath shower text
+         vector
+       ];
+       description = "Khronos texture format";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "kubernetes-client" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
      , bytestring, connection, containers, data-default-class, either
···
      }:
      mkDerivation {
        pname = "language-dickinson";
-       version = "1.3.0.0";
-       sha256 = "0pi983l9s182c4xcqj7xq3idv8wnshx7zva5a5wfhws403y5yy7v";
+       version = "1.3.0.1";
+       sha256 = "0681w4rz547if52yk0k32drhllx0k906nir0gs6xv0pqxkjc07ri";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
     ({ mkDerivation, accelerate, base, lens }:
      mkDerivation {
        pname = "lens-accelerate";
-       version = "0.2.0.0";
-       sha256 = "099vvakv7gq9sr9mh3hxj5byxxb4dw8lw7y1g3c4j1kz4gf2vxfk";
-       revision = "1";
-       editedCabalFile = "0ggm157i4bmgh7k0dv9zncgn4agwk7zn5wvsknxsnfqzy45qabi9";
+       version = "0.3.0.0";
+       sha256 = "1sk3iy5qv24mifx0gwd5z714lf3y3s4zpbff09mqk42whk2sdd0y";
        libraryHaskellDepends = [ accelerate base lens ];
-       description = "Instances to mix lens with accelerate";
+       description = "Instances to mix lens with Accelerate";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
···
      }:
      mkDerivation {
        pname = "libarchive";
-       version = "2.2.5.2";
-       sha256 = "1qydgw1c74c0xp2d5d85qbyyng9rgqgxgvj6fhh94wzgkxj99al6";
+       version = "3.0.0.0";
+       sha256 = "0qwnp5jzmlvi7bpbh1dhz3lp91qf5phr8hb7m3h5q0a50d72dqpp";
        setupHaskellDepends = [ base Cabal chs-cabal ];
        libraryHaskellDepends = [
          base bytestring composition-prelude deepseq dlist filepath mtl
···
        license = stdenv.lib.licenses.publicDomain;
      }) {ffi = null;};
 
+  "libfuse3" = callPackage
+    ({ mkDerivation, base, bytestring, clock, fuse3, resourcet, time
+     , unix
+     }:
+     mkDerivation {
+       pname = "libfuse3";
+       version = "0.1.0.0";
+       sha256 = "0qwlaqcpmi7dfsjk219z0hrqmayg46qx1cwj1vcz1nfv8jlm8yif";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring clock resourcet time unix
+       ];
+       libraryPkgconfigDepends = [ fuse3 ];
+       description = "A Haskell binding for libfuse-3.x";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {inherit (pkgs) fuse3;};
+
   "libgit" = callPackage
     ({ mkDerivation, base, mtl, process }:
      mkDerivation {
···
        testPkgconfigDepends = [ libsodium ];
        description = "Low-level bindings to the libsodium C library";
        license = stdenv.lib.licenses.isc;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) libsodium;};
 
   "libssh2" = callPackage
···
      }:
      mkDerivation {
        pname = "linear-accelerate";
-       version = "0.6.0.0";
-       sha256 = "1bwqbs4816xrrc0bcf3nllad1an7c8gv2n9d1qv3ybk7s4fw288s";
-       revision = "1";
-       editedCabalFile = "1sf1jqpymhkdl5xn1br13qkw3zyg7pqmmwcczcw19zpgwk4ai19v";
+       version = "0.7.0.0";
+       sha256 = "1rdbmchbvrg5g0ndfppswydn15qbp2k9dvx7wapfpy8971qqf2df";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          accelerate base distributive lens linear
···
        benchmarkHaskellDepends = [ aeson attoparsec base criterion text ];
        description = "Liquid template language library";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "liquid-base" = callPackage
     ({ mkDerivation, base, Cabal, liquid-ghc-prim, liquidhaskell }:
      mkDerivation {
        pname = "liquid-base";
-       version = "4.14.0.0";
-       sha256 = "07qy1xc04wbd46cd0zgw3znczang1h1sgllxswjjimaw1wp49xh3";
+       version = "4.14.1.0";
+       sha256 = "0w5pwksyf8fbr8v8j5mshcysxlbz4lxdvmayc3pj8cm8xcdrvzkm";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal liquidhaskell ];
        libraryHaskellDepends = [ base liquid-ghc-prim liquidhaskell ];
        description = "Drop-in base replacement for LiquidHaskell";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "liquid-bytestring" = callPackage
···
        libraryHaskellDepends = [ bytestring liquid-base liquidhaskell ];
        description = "LiquidHaskell specs for the bytestring package";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "liquid-containers" = callPackage
···
        libraryHaskellDepends = [ containers liquid-base liquidhaskell ];
        description = "LiquidHaskell specs for the containers package";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "liquid-fixpoint" = callPackage
···
      }:
      mkDerivation {
        pname = "liquid-fixpoint";
-       version = "0.8.10.1";
-       sha256 = "0mavpfwsm3a6cnw2p75hvjch1j0nb8qm1rflq304iz6msg9zbhsv";
+       version = "0.8.10.2";
+       sha256 = "1sdd88p5mz9xfqk9pbn138ixxdrq089iy5imskvhx66dwwrmrr8l";
        configureFlags = [ "-fbuild-external" ];
        isLibrary = true;
        isExecutable = true;
···
        doCheck = false;
        description = "Predicate Abstraction-based Horn-Clause/Implication Constraint Solver";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) git; inherit (pkgs) nettools; 
          inherit (pkgs) ocaml; inherit (pkgs) z3;};
 
···
        libraryHaskellDepends = [ ghc-prim liquidhaskell ];
        description = "Drop-in ghc-prim replacement for LiquidHaskell";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "liquid-parallel" = callPackage
···
        libraryHaskellDepends = [ liquid-base liquidhaskell parallel ];
        description = "LiquidHaskell specs for the parallel package";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "liquid-platform" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "liquid-platform";
-       version = "0.8.10.1";
-       sha256 = "1l1qpg08fhf2xbj7i3hy36idm2z4yggg7mlzyncjkjlqxdnmm44k";
+       version = "0.8.10.2";
+       sha256 = "1rhpq04nl9gcm9rwjd261ssn8q59pdcpfna0xwkcv3gmkgirwzgf";
        isLibrary = false;
        isExecutable = true;
        description = "A battery-included platform for LiquidHaskell";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "liquid-prelude" = callPackage
···
      }:
      mkDerivation {
        pname = "liquid-prelude";
-       version = "0.8.10.1";
-       sha256 = "0pcz59spsg3x4c5553yksfqgdjlh2c33id10b6p8hnm6hyqcbjvn";
+       version = "0.8.10.2";
+       sha256 = "0s52kd2x4h24j6z7cjkrarnqr7kp198qal55y84740rllskv3ijh";
        setupHaskellDepends = [ base Cabal liquidhaskell ];
        libraryHaskellDepends = [
          bytestring containers liquid-base liquidhaskell
        ];
        description = "General utility modules for LiquidHaskell";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "liquid-vector" = callPackage
···
        libraryHaskellDepends = [ liquid-base liquidhaskell vector ];
        description = "LiquidHaskell specs for the vector package";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "liquidhaskell" = callPackage
···
      }:
      mkDerivation {
        pname = "liquidhaskell";
-       version = "0.8.10.1";
-       sha256 = "0xyxb0sifqgp1hl6lcydf7svw6w968hd3dgmnlly8ddpdmhsw9jm";
-       revision = "1";
-       editedCabalFile = "0bg9660c5454jiimgwciimd114r81gfjdad6nzbgyhkvilfd0wad";
+       version = "0.8.10.2";
+       sha256 = "0byh5lia3kb44sgmilya881dp9il3n5qvrn16brnkvl9xhr9rdyi";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          aeson base binary bytestring Cabal cereal cmdargs containers
          data-default deepseq Diff directory extra filepath fingertree ghc
          ghc-boot ghc-paths ghc-prim githash gitrev hashable hscolour
-         liquid-fixpoint mtl optics optparse-simple parsec pretty split syb
-         template-haskell temporary text time transformers
-         unordered-containers vector
+         liquid-fixpoint mtl optics optparse-applicative optparse-simple
+         parsec pretty split syb template-haskell temporary text time
+         transformers unordered-containers vector
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
···
        testSystemDepends = [ z3 ];
        description = "Liquid Types for Haskell";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) z3;};
 
   "liquidhaskell-cabal" = callPackage
···
      }) {};
 
   "llvm-pretty" = callPackage
-    ({ mkDerivation, base, containers, monadLib, parsec, pretty }:
+    ({ mkDerivation, base, containers, microlens, microlens-th
+     , monadLib, parsec, pretty, template-haskell, th-abstraction
+     }:
      mkDerivation {
        pname = "llvm-pretty";
-       version = "0.7.1.1";
-       sha256 = "17lb4jfkaxz2ahjfvq2mxnb82k209qg13rhdg76v3j8yahr5z0a2";
-       libraryHaskellDepends = [ base containers monadLib parsec pretty ];
+       version = "0.11.0";
+       sha256 = "17jw5i68fz2vk40dcqf8k7j6j6h8acg4fhnyygb72jbk17md4q94";
+       libraryHaskellDepends = [
+         base containers microlens microlens-th monadLib parsec pretty
+         template-haskell th-abstraction
+       ];
        description = "A pretty printing library inspired by the llvm binding";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
 
   "log-elasticsearch" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring
-     , bloodhound, bytestring, deepseq, http-client, http-client-tls
-     , log-base, semigroups, text, text-show, time, transformers
-     , unordered-containers, vector
+     , bytestring, deepseq, http-client, http-client-tls, http-types
+     , log-base, network-uri, semigroups, text, text-show, time
+     , transformers, unordered-containers, vector
      }:
      mkDerivation {
        pname = "log-elasticsearch";
-       version = "0.10.2.0";
-       sha256 = "0kcixyklnak34v8vmmpw8vpm1mvf3wll6xpcdvfg1c75wc9n1hqy";
+       version = "0.11.0.0";
+       sha256 = "1l64mxk3zmlfsqwlhsq62jp8rawj3jbw9izihg7555q51pbqlg5w";
        libraryHaskellDepends = [
-         aeson aeson-pretty base base64-bytestring bloodhound bytestring
-         deepseq http-client http-client-tls log-base semigroups text
-         text-show time transformers unordered-containers vector
+         aeson aeson-pretty base base64-bytestring bytestring deepseq
+         http-client http-client-tls http-types log-base network-uri
+         semigroups text text-show time transformers unordered-containers
+         vector
        ];
        description = "Structured logging solution (Elasticsearch back end)";
        license = stdenv.lib.licenses.bsd3;
···
        ];
        description = "A mtl-style monad transformer for general purpose & compositional logging";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "logging-effect-extra" = callPackage
···
        testHaskellDepends = [ base mtl tasty tasty-hunit ];
        description = "A backtracking logic-programming monad";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "logict_0_7_0_3" = callPackage
+    ({ mkDerivation, base, mtl, tasty, tasty-hunit }:
+     mkDerivation {
+       pname = "logict";
+       version = "0.7.0.3";
+       sha256 = "0psihirap7mrn3ly1h9dvgvgjsqbqwji8m13fm48zl205mpfh73r";
+       libraryHaskellDepends = [ base mtl ];
+       testHaskellDepends = [ base mtl tasty tasty-hunit ];
+       description = "A backtracking logic-programming monad";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "logict-state" = callPackage
···
      }:
      mkDerivation {
        pname = "lorentz";
-       version = "0.5.0";
-       sha256 = "0wvvxc49bc8cyfhhwzzhrdf3sia03d8hx2cxpjg3jab8bbxbqza1";
+       version = "0.6.0";
+       sha256 = "1mzw2m46g5gffhihjfwimrhwqlky3z420b5wifdvxybm5vfc0qm2";
        libraryHaskellDepends = [
          aeson-pretty base bimap bytestring constraints containers
          data-default first-class-families fmt interpolate lens morley
···
     ({ mkDerivation, base, lucid }:
      mkDerivation {
        pname = "lucid-cdn";
-       version = "0.1.1.1";
-       sha256 = "1dl44rc5b3wrgfcllp6h1sw4w18jgglh1grh5w9g37rcxi2cxwll";
+       version = "0.2.0.0";
+       sha256 = "1b4s4yfhxnixc33kz0hnj2v5vrwag4vnssp8ma0vjgh17b9g4qzr";
        libraryHaskellDepends = [ base lucid ];
        description = "Curated list of CDN imports for lucid";
        license = stdenv.lib.licenses.mit;
···
        broken = true;
      }) {};
 
+  "lz4-frame-conduit" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, conduit-extra
+     , containers, hspec, inline-c, optparse-applicative, QuickCheck
+     , raw-strings-qq, resourcet, template-haskell, text, unliftio
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "lz4-frame-conduit";
+       version = "0.1.0.0";
+       sha256 = "0nvvf42m4vbadl869hgyqrzbzbxp9q7rlbrldi4y6zw48ig21r1d";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring conduit conduit-extra containers inline-c
+         raw-strings-qq resourcet template-haskell unliftio unliftio-core
+       ];
+       executableHaskellDepends = [
+         base bytestring conduit conduit-extra optparse-applicative
+         resourcet text
+       ];
+       testHaskellDepends = [
+         base bytestring conduit conduit-extra hspec QuickCheck resourcet
+         unliftio-core
+       ];
+       description = "Conduit implementing the official LZ4 frame streaming format";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "lz4-hs" = callPackage
     ({ mkDerivation, base, bytestring, c2hs, criterion, filepath, tasty
      , tasty-hunit, temporary
      }:
      mkDerivation {
        pname = "lz4-hs";
-       version = "0.1.4.1";
-       sha256 = "15jm8lbwhgp29yvnwsxsmbixvgpxrnw7jc96zwmzbqx365r4dfqr";
+       version = "0.1.5.0";
+       sha256 = "0qqv6n7hjcjkc1pzhwkdr9l1kfb8rqndx2lfm6j4bhmvrwwrn8lw";
        libraryHaskellDepends = [ base bytestring ];
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [ base bytestring tasty tasty-hunit ];
···
      }) {};
 
   "mime-mail-ses" = callPackage
-    ({ mkDerivation, base, base64-bytestring, byteable, bytestring
-     , conduit, cryptohash, http-client, http-client-tls, http-conduit
-     , http-types, mime-mail, old-locale, text, time, transformers
-     , xml-conduit, xml-types
-     }:
-     mkDerivation {
-       pname = "mime-mail-ses";
-       version = "0.4.1";
-       sha256 = "1w6k4cm5yab9dhg7yn6mp7jzk1zdwpnzc6c1xb3vz3rdwp8jjvx7";
-       libraryHaskellDepends = [
-         base base64-bytestring byteable bytestring conduit cryptohash
-         http-client http-client-tls http-conduit http-types mime-mail
-         old-locale text time transformers xml-conduit xml-types
-       ];
-       description = "Send mime-mail messages via Amazon SES";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "mime-mail-ses_0_4_2" = callPackage
     ({ mkDerivation, base, base16-bytestring, base64-bytestring
      , byteable, bytestring, case-insensitive, conduit, cryptohash
      , http-client, http-client-tls, http-conduit, http-types, mime-mail
···
        ];
        description = "Send mime-mail messages via Amazon SES";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "mime-string" = callPackage
···
        ];
        description = "monad-classes based typeclass for Ollie's logging-effect LoggingT";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "monad-codec" = callPackage
···
      }:
      mkDerivation {
        pname = "morley";
-       version = "1.5.0";
-       sha256 = "151idw4dhdlsw9ga8q0mp3vnv520ljmkr0wm2hhhd7k0xliy177a";
+       version = "1.6.0";
+       sha256 = "0i06yh7v2zz8lcjhc96k5wsfj9i401mgs05myg46ml04zz4pw408";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "A Markov stochastic transition operator with logging";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "mwc-random" = callPackage
···
     ({ mkDerivation, accelerate, base, mwc-random }:
      mkDerivation {
        pname = "mwc-random-accelerate";
-       version = "0.1.0.0";
-       sha256 = "1qrji6b39zp5wrgz5c59xv06l3khhp4fv2ybdmx4ac5i28yx7yih";
-       revision = "3";
-       editedCabalFile = "1a7xx3mcli9fx5lqg1zxwqbrgzvgbssn3vprh4wp8zg58pqic6ic";
+       version = "0.2.0.0";
+       sha256 = "1a8b36l60p29461y0gacgjzarlyrncl54r7x4zh2rgvs2w7mjdc5";
        libraryHaskellDepends = [ accelerate base mwc-random ];
        description = "Generate Accelerate arrays filled with high quality pseudorandom numbers";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "network-uri-json";
-       version = "0.3.1.1";
-       sha256 = "0akyhgi79pzhvfq47risrqmr6hi409fnz1ivwpwwfc4laimf3mky";
+       version = "0.4.0.0";
+       sha256 = "1hnsk8xsa89p4ywvyb4xfdk3l16mlhmb73sy1vbgckc7mlv3mmb4";
        libraryHaskellDepends = [ aeson base network-uri text ];
        testHaskellDepends = [
          aeson base hspec network-arbitrary network-uri test-invariant text
···
      }:
      mkDerivation {
        pname = "nix-tree";
-       version = "0.1.0.0";
-       sha256 = "0agj882mfnr53jlpn1cnds31b78qw3a13md1ap6jj2rnxs2zjcai";
+       version = "0.1.1.0";
+       sha256 = "1dciwsw7cv1f73awrqr3gw3zj3mizaw53q3ibkawq9gbfsfg8yiz";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "nonempty-containers";
-       version = "0.3.4.0";
-       sha256 = "1np8gypq49j90clavh17wzxp9y6z23lngal815jsg4p35qc0h01l";
+       version = "0.3.4.1";
+       sha256 = "0cpn0f0gnir9w366hw2906316qx5yc06rrrlv67xba1p66507m83";
        libraryHaskellDepends = [
          aeson base comonad containers deepseq nonempty-vector semigroupoids
          these vector
···
      }:
      mkDerivation {
        pname = "nvvm";
-       version = "0.9.0.0";
-       sha256 = "00ggaycs5z2b617kgjv851ahrakd4v8w374qbym19r1ccrxkdhhb";
+       version = "0.10.0.0";
+       sha256 = "188zf4hlqgjj5xgsfvrkynhq8pc29qfkaz6rp61ij3adc30410al";
        setupHaskellDepends = [
          base Cabal cuda directory filepath template-haskell
        ];
-       libraryHaskellDepends = [ base bytestring cuda template-haskell ];
+       libraryHaskellDepends = [
+         base bytestring cuda directory filepath template-haskell
+       ];
        libraryToolDepends = [ c2hs ];
        description = "FFI bindings to NVVM";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "opaleye_0_7_0_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.7.0.0";
+       sha256 = "1a4ymnfw7gdqf2b5lsrfhxf53ybjfcyx31fdxn52fv89jc2h2yiy";
+       libraryHaskellDepends = [
+         aeson base base16-bytestring bytestring case-insensitive
+         contravariant postgresql-simple pretty product-profunctors
+         profunctors scientific semigroups text time time-locale-compat
+         transformers uuid void
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers contravariant dotenv hspec
+         hspec-discover multiset postgresql-simple product-profunctors
+         profunctors QuickCheck semigroups text time transformers uuid
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "An SQL-generating DSL targeting PostgreSQL";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "opaleye-classy" = callPackage
     ({ mkDerivation, base, bytestring, lens, mtl, opaleye
      , postgresql-simple, product-profunctors, transformers
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
-  "opentelemetry_0_6_0" = callPackage
+  "opentelemetry_0_6_1" = callPackage
     ({ mkDerivation, base, bytestring, exceptions, ghc-trace-events
      , hashable
      }:
      mkDerivation {
        pname = "opentelemetry";
-       version = "0.6.0";
-       sha256 = "0gl3xax7gz89fc12lyw468qhailgja06skj6siscq9pip03gj6ck";
+       version = "0.6.1";
+       sha256 = "0i88ciig40gil4gaj95qw28c2racdr2jb6rcpnsf60fzkqc8b3fk";
        libraryHaskellDepends = [
          base bytestring exceptions ghc-trace-events hashable
        ];
···
        broken = true;
      }) {};
 
-  "opentelemetry-extra_0_6_0" = callPackage
+  "opentelemetry-extra_0_6_1" = callPackage
     ({ mkDerivation, aeson, async, base, binary, bytestring, clock
      , containers, directory, exceptions, filepath, gauge
      , generic-arbitrary, ghc-events, hashable, hashtables, http-client
···
      }:
      mkDerivation {
        pname = "opentelemetry-extra";
-       version = "0.6.0";
-       sha256 = "025fsryqzv0cfny1myrhs4bdrdg8sfp86rvxf671sbl8nli48x1a";
+       version = "0.6.1";
+       sha256 = "0ggxkhcrjj8sg6zf9jnp1j05wwlsay6k95c79j9j3dvw8qy2yjbx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
-  "opentelemetry-lightstep_0_6_0" = callPackage
+  "opentelemetry-lightstep_0_6_1" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, clock, containers
      , exceptions, filepath, ghc-events, http-client, http-client-tls
      , http-types, network, opentelemetry, opentelemetry-extra
···
      }:
      mkDerivation {
        pname = "opentelemetry-lightstep";
-       version = "0.6.0";
-       sha256 = "09xqda7hxx4dn85hs2zh7y3jjxvi7xprcpv8mmam38hzyhjw2rv7";
+       version = "0.6.1";
+       sha256 = "1a7rrm5aahqh63j0rr7nvd4y3q64m8qr7is0r0a17fwkkpppmyln";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
-  "opentelemetry-wai_0_6_0" = callPackage
+  "opentelemetry-wai_0_6_1" = callPackage
     ({ mkDerivation, base, bytestring, http-types, opentelemetry, text
      , wai
      }:
      mkDerivation {
        pname = "opentelemetry-wai";
-       version = "0.6.0";
-       sha256 = "1bqq1fs7krckx43w2j4pvfncbyy60rrh6w8n1pcvb629dary5lwn";
+       version = "0.6.1";
+       sha256 = "0g1a044sphd35z9crc8wbxsk4hfh1gpfi4g8rr1k4f842hznj7nf";
        libraryHaskellDepends = [
          base bytestring http-types opentelemetry text wai
        ];
···
      }:
      mkDerivation {
        pname = "optparse-simple";
-       version = "0.1.1.2";
-       sha256 = "1r00hkri42vyx552l8hcd1779fxiyl9w4k0pql915zsprirn8w82";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base githash optparse-applicative template-haskell transformers
-       ];
-       testHaskellDepends = [ base bytestring directory ];
-       description = "Simple interface to optparse-applicative";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "optparse-simple_0_1_1_3" = callPackage
-    ({ mkDerivation, base, bytestring, directory, githash
-     , optparse-applicative, template-haskell, transformers
-     }:
-     mkDerivation {
-       pname = "optparse-simple";
        version = "0.1.1.3";
        sha256 = "1wymqhac2sngkka8w880gq6y1kk3xs0flbv4mrhfgzrplhax8r9k";
        isLibrary = true;
···
        testHaskellDepends = [ base bytestring directory ];
        description = "Simple interface to optparse-applicative";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "optparse-text" = callPackage
···
        broken = true;
      }) {};
 
-  "pandoc-plot_0_9_1_0" = callPackage
+  "pandoc-plot_0_9_2_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, criterion
      , data-default, directory, filepath, githash, hashable, hspec
      , hspec-expectations, lifted-async, mtl, optparse-applicative
···
      }:
      mkDerivation {
        pname = "pandoc-plot";
-       version = "0.9.1.0";
-       sha256 = "0vfcn0h5x9jsf3jjriqd6wfa9cpi7icz4k8pkqmhjz5sgs2yv7i4";
+       version = "0.9.2.0";
+       sha256 = "0fryriyqlmfc82nqbqw7a8n7325wwag29v3ag61s600jw66i9fsc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "pantry_0_5_1_1" = callPackage
+  "pantry_0_5_1_2" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal
      , casa-client, casa-types, conduit, conduit-extra, containers
      , cryptonite, cryptonite-conduit, digest, exceptions, filelock
···
      }:
      mkDerivation {
        pname = "pantry";
-       version = "0.5.1.1";
-       sha256 = "1q1q8jflhd5r70czsclkj27yqk4v8b1njdw8f4qb3xvf9c3gzl70";
+         semigroups tfp transformers unique-logic-tf utility-ht
+       sha256 = "1ix1y334l4a7zcqm8i849g67mgvkqzikbhcbkqc1d6hg1lhc7xzr";
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring Cabal casa-client casa-types
          conduit conduit-extra containers cryptonite cryptonite-conduit
···
     ({ mkDerivation, base, binary, path }:
      mkDerivation {
        pname = "path-binary-instance";
-       version = "0.1.0.0";
-       sha256 = "1mrmp58s7f88hyq493h39c1f19r92yh2qw1diml61iwhm765j7ir";
+       version = "0.1.0.1";
+       sha256 = "19ck3ja66vcgl90wyw6r9d2h50kdv9gjs7sxjgciam6v6867vb0y";
        libraryHaskellDepends = [ base binary path ];
        description = "Binary instance for Path";
        license = stdenv.lib.licenses.mit;
···
     ({ mkDerivation, base, path }:
      mkDerivation {
        pname = "path-like";
-       version = "0.2.0.1";
-       sha256 = "03d5kqs6xr22dl7gjydi1nlzy13wsc0dkmd93pwf37yp85y4bxrp";
+       version = "0.2.0.2";
+       sha256 = "1hr58zcgcybd34zzas5kf0jgcm5z2wdlbhskwj9233503nnlwkq9";
        libraryHaskellDepends = [ base path ];
        description = "PathLike, FileLike and DirLike type classes for the Path library";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "persistent-mongoDB";
-       version = "2.10.0.0";
-       sha256 = "1z895y21raak3x9qw05hgif5qyvr6c7pkc59wzg7irk8mxijyf4n";
+       version = "2.10.0.1";
+       sha256 = "194cxlxyaxwzgm7a7q8530bh842s5s1vmq33pclldp78nfy1dczm";
        libraryHaskellDepends = [
          aeson base bson bytestring cereal conduit http-api-data mongoDB
          network path-pieces persistent resource-pool resourcet text time
···
      }) {};
 
   "persistent-redis" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, binary, bytestring, hedis
-     , http-api-data, monad-control, mtl, path-pieces, persistent
-     , persistent-template, scientific, template-haskell, text, time
-     , transformers, utf8-string
+    ({ mkDerivation, aeson, base, binary, bytestring, hedis
+     , http-api-data, mtl, path-pieces, persistent, persistent-template
+     , scientific, template-haskell, text, time, transformers
+     , utf8-string
      }:
      mkDerivation {
        pname = "persistent-redis";
-       version = "2.5.2.2";
-       sha256 = "1mkdc3s39h0zqzf86zzwyfxfpc4fasrhpfdypkj8mkljbh7v1i1l";
+       version = "2.5.2.5";
+       sha256 = "0h2bwr5svj36n3axnrgnrzkysg4ywf9d97x4fwwsjgn01gwr262k";
        libraryHaskellDepends = [
-         aeson attoparsec base binary bytestring hedis http-api-data
-         monad-control mtl path-pieces persistent scientific text time
-         transformers utf8-string
+         aeson base binary bytestring hedis http-api-data mtl path-pieces
+         persistent scientific text time transformers utf8-string
        ];
        testHaskellDepends = [
-         aeson attoparsec base binary bytestring hedis http-api-data
-         monad-control mtl path-pieces persistent persistent-template
-         scientific template-haskell text time transformers utf8-string
+         aeson base binary bytestring hedis http-api-data mtl path-pieces
+         persistent persistent-template scientific template-haskell text
+         time transformers utf8-string
        ];
        description = "Backend for persistent library using Redis";
        license = stdenv.lib.licenses.bsd3;
···
        ];
        description = "Tests for Persistent";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "persistent-test_2_0_3_2" = callPackage
+    ({ mkDerivation, aeson, base, blaze-html, bytestring, conduit
+     , containers, exceptions, hspec, hspec-expectations, HUnit
+     , monad-control, monad-logger, mtl, path-pieces, persistent
+     , persistent-template, QuickCheck, quickcheck-instances, random
+     , resourcet, text, time, transformers, transformers-base, unliftio
+     , unliftio-core, unordered-containers
+     }:
+     mkDerivation {
+       pname = "persistent-test";
+       version = "2.0.3.2";
+       sha256 = "0d7a6m4qm6xzyv7h2fqn9hgv7r7q6dwh7x04ddsrygjxdgpwgqf3";
+       libraryHaskellDepends = [
+         aeson base blaze-html bytestring conduit containers exceptions
+         hspec hspec-expectations HUnit monad-control monad-logger mtl
+         path-pieces persistent persistent-template QuickCheck
+         quickcheck-instances random resourcet text time transformers
+         transformers-base unliftio unliftio-core unordered-containers
+       ];
+       description = "Tests for Persistent";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "persistent-typed-db" = callPackage
···
        broken = true;
      }) {};
 
+  "polysemy-http" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base-noprelude, bytestring
+     , case-insensitive, co-log-core, co-log-polysemy, composition
+     , containers, data-default, either, hedgehog, http-client
+     , http-client-tls, http-conduit, http-types, lens, mono-traversable
+     , network, polysemy, polysemy-plugin, relude, servant
+     , servant-client, servant-server, string-interpolate, tasty
+     , tasty-hedgehog, template-haskell, text, warp
+     }:
+     mkDerivation {
+       pname = "polysemy-http";
+       version = "0.1.0.0";
+       sha256 = "025dch3cq8bgyy78yg4jrcxxmkdyl03y38zrgjhfv00rrwcffhm0";
+       libraryHaskellDepends = [
+         aeson ansi-terminal base-noprelude bytestring case-insensitive
+         co-log-core co-log-polysemy composition containers data-default
+         either http-client http-client-tls http-conduit http-types lens
+         mono-traversable polysemy polysemy-plugin relude string-interpolate
+         template-haskell text
+       ];
+       testHaskellDepends = [
+         aeson ansi-terminal base-noprelude bytestring case-insensitive
+         co-log-core co-log-polysemy composition containers data-default
+         either hedgehog http-client http-client-tls http-conduit http-types
+         lens mono-traversable network polysemy polysemy-plugin relude
+         servant servant-client servant-server string-interpolate tasty
+         tasty-hedgehog template-haskell text warp
+       ];
+       description = "Polysemy effect for http-client";
+       license = "BSD-2-Clause-Patent";
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "polysemy-optics" = callPackage
     ({ mkDerivation, base, optics, polysemy, polysemy-zoo }:
      mkDerivation {
···
        libraryHaskellDepends = [ base lucid prettyprinter text ];
        description = "A prettyprinter backend for lucid";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "prettyprinter-vty" = callPackage
···
      }:
      mkDerivation {
        pname = "prolog";
-       version = "0.3";
-       sha256 = "02i79irax13rny953k6fvswsgbif9nnvysnnbq3k4w37b3g5maiv";
+       version = "0.3.2";
+       sha256 = "1clh7gfqh2yf17jc453y8cc8qcga9h0j5a60nfr1sjd5byr8j8ab";
        libraryHaskellDepends = [
          base containers mtl parsec syb template-haskell th-lift
          transformers
···
      }:
      mkDerivation {
        pname = "proto-lens-jsonpb";
-       version = "0.2.0.1";
-       sha256 = "0hsjn0iy0bbpb1sczk6vj2vah5f60w8cpm2gach5zlb9qpvkg4x4";
+       version = "0.2.0.2";
+       sha256 = "1r98841byxkg5941yjrw15n56i0x68qr3gk29bimwcfifdf0idm2";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring bytestring
          proto-lens-runtime text vector
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "psql-utils" = callPackage
+    ({ mkDerivation, aeson, base, hashable, postgresql-simple
+     , resource-pool, time
+     }:
+     mkDerivation {
+       pname = "psql-utils";
+       version = "0.1.0.0";
+       sha256 = "09s26lqqdy2qah6i0yim9g2h61hramhij7r9kbcccbc3fgv4sd6s";
+       libraryHaskellDepends = [
+         aeson base hashable postgresql-simple resource-pool time
+       ];
+       description = "PostgreSQL Simple util tools";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "psqueues" = callPackage
     ({ mkDerivation, array, base, containers, criterion, deepseq
      , fingertree-psqueue, ghc-prim, hashable, HUnit, mtl, PSQueue
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "quickjs-hs" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, exceptions
+     , HUnit, inline-c, mtl, QuickCheck, scientific, string-conv, tasty
+     , tasty-hunit, tasty-quickcheck, text, time, transformers
+     , unliftio-core, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "quickjs-hs";
+       version = "0.1.2.1";
+       sha256 = "0dbypa7p3x5j2nmbw2qvs4aik74jfkfa9b0mmv2290p6sj9ag1hd";
+       revision = "1";
+       editedCabalFile = "0f18980s2sky2fnrdnadyhivjhbzxcq9m3isnji8q2gbzpbywca7";
+       libraryHaskellDepends = [
+         aeson base bytestring containers exceptions inline-c mtl scientific
+         string-conv text time transformers unliftio-core
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base exceptions HUnit QuickCheck tasty tasty-hunit
+         tasty-quickcheck text unordered-containers vector
+       ];
+       description = "Wrapper for the QuickJS Javascript Engine";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "quicklz" = callPackage
     ({ mkDerivation, base, bytestring, QuickCheck, test-framework
      , test-framework-quickcheck2
···
        pname = "random";
        version = "1.2.0";
        sha256 = "1pmr7zbbqg58kihhhwj8figf5jdchhi7ik2apsyxbgsqq3vrqlg4";
+       revision = "1";
+       editedCabalFile = "11l9bcjy63qvcm4n7djp2l1l8668hbckkkdb2nj5g6iyy9pb2sa9";
        libraryHaskellDepends = [ base bytestring deepseq mtl splitmix ];
        testHaskellDepends = [
          base bytestring containers doctest mwc-random primitive smallcheck
···
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
-  "reanimate_0_4_1_0" = callPackage
+  "reanimate_0_4_2_0" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, array, attoparsec, base
-     , base64-bytestring, bytestring, cassava, cereal, chiphunk, colour
-     , containers, cubicbezier, directory, earcut, filepath, fsnotify
-     , geojson, hashable, hmatrix, JuicyPixels, lens, linear, matrix
-     , mtl, neat-interpolation, open-browser, optparse-applicative
-     , parallel, process, random, random-shuffle, reanimate-svg, split
-     , temporary, text, time, vector, vector-space, websockets, xml
+     , base64-bytestring, bytestring, cassava, cereal, colour
+     , containers, cubicbezier, directory, filelock, filepath, fsnotify
+     , geojson, ghcid, hashable, hgeometry, hgeometry-combinatorial
+     , JuicyPixels, lens, linear, matrix, mtl, neat-interpolation
+     , open-browser, optparse-applicative, parallel, process, QuickCheck
+     , random, random-shuffle, reanimate-svg, split, tasty, tasty-golden
+     , tasty-hunit, tasty-quickcheck, tasty-rerun, temporary, text, time
+     , vector, vector-space, websockets, xml
      }:
      mkDerivation {
        pname = "reanimate";
-       version = "0.4.1.0";
-       sha256 = "12mql2i3433y3cj4x3rcilmvja4cnyk9y5cykw16sg30kbp1riki";
+       version = "0.4.2.0";
+       sha256 = "0dihh2k0cvh17qb37pfn1h6g620yzp923wrjqy22qbmlld896snk";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson ansi-terminal array attoparsec base base64-bytestring
-         bytestring cassava cereal chiphunk colour containers cubicbezier
-         directory earcut filepath fsnotify geojson hashable hmatrix
-         JuicyPixels lens linear matrix mtl neat-interpolation open-browser
-         optparse-applicative parallel process random random-shuffle
-         reanimate-svg split temporary text time vector vector-space
-         websockets xml
+         bytestring cassava cereal colour containers cubicbezier directory
+         filelock filepath fsnotify geojson ghcid hashable hgeometry
+         hgeometry-combinatorial JuicyPixels lens linear matrix mtl
+         neat-interpolation open-browser optparse-applicative parallel
+         process random random-shuffle reanimate-svg split temporary text
+         time vector vector-space websockets xml
+       ];
+       testHaskellDepends = [
+         base bytestring directory filepath linear process QuickCheck tasty
+         tasty-golden tasty-hunit tasty-quickcheck tasty-rerun temporary
+         text vector
        ];
        description = "Animation library based on SVGs";
        license = stdenv.lib.licenses.publicDomain;
···
      }:
      mkDerivation {
        pname = "recommender-als";
-       version = "0.2.0.0";
-       sha256 = "14nw3ns52da4jlbwblbavchxzv1pjhc1zkjzcwfrqznxgsd5525p";
+       version = "0.2.1.1";
+       sha256 = "0qc91hn42mc2pmljb836chdas1jzsrqbg44cjylx31y0y72dmhdq";
        libraryHaskellDepends = [
          base containers data-default-class hmatrix parallel random vector
        ];
···
      }:
      mkDerivation {
        pname = "registry";
-       version = "0.1.9.1";
-       sha256 = "0vnx2sq3m6mqm1wcicknf7b8pfamx4pbn51hmzs6arwnvsq23vng";
-       libraryHaskellDepends = [
-         base containers exceptions hashable mmorph mtl protolude resourcet
-         semigroupoids semigroups template-haskell text transformers-base
-       ];
-       testHaskellDepends = [
-         async base bytestring containers directory exceptions generic-lens
-         hashable hedgehog io-memoize mmorph MonadRandom mtl multimap
-         protolude random resourcet semigroupoids semigroups tasty
-         tasty-discover tasty-hedgehog tasty-th template-haskell text
-         transformers-base universum
-       ];
-       testToolDepends = [ tasty-discover ];
-       description = "data structure for assembling components";
-       license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "registry_0_1_9_3" = callPackage
-    ({ mkDerivation, async, base, bytestring, containers, directory
-     , exceptions, generic-lens, hashable, hedgehog, io-memoize, mmorph
-     , MonadRandom, mtl, multimap, protolude, random, resourcet
-     , semigroupoids, semigroups, tasty, tasty-discover, tasty-hedgehog
-     , tasty-th, template-haskell, text, transformers-base, universum
-     }:
-     mkDerivation {
-       pname = "registry";
        version = "0.1.9.3";
        sha256 = "1x418lv2nnw5ryrinciq1dg7wgmz0zsvv8v3mfrp38rx5x88hbic";
        libraryHaskellDepends = [
···
        pname = "repa-io";
        version = "3.4.1.1";
        sha256 = "1nm9kfin6fv016r02l74c9hf8pr1rz7s33i833cqpyw8m6bcmnxm";
-       revision = "4";
-       editedCabalFile = "1lswfxmfn31gm2ayqwns9q9kpbad69scxpq6ybyzxkb9jd0jx4bl";
+       revision = "5";
+       editedCabalFile = "1v9bza21a3h0pkaxs628jjfli157d44i757da250fxwwamk8sg88";
        libraryHaskellDepends = [
          base binary bmp bytestring old-time repa vector
        ];
···
        testHaskellDepends = [ base directory hspec process ];
        description = "Stack wrapper for single-file Haskell programs";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "runmany" = callPackage
···
      }:
      mkDerivation {
        pname = "safe-exceptions";
-       version = "0.1.7.0";
-       sha256 = "0sd0zfsm9pcll5bzzj523rbn45adjrnavdkz52hgmdjjgdcdrk8q";
-       revision = "6";
-       editedCabalFile = "0x82m44qwf3fls3ypbdca958l9hhfqyfip6rzzxi7648f0sasv21";
+       version = "0.1.7.1";
+       sha256 = "0gkxacfiqp55xzbmpz5i5c4kqma8jal49q7c8gl9n9qq5c5dvxjb";
        libraryHaskellDepends = [ base deepseq exceptions transformers ];
        testHaskellDepends = [ base hspec void ];
        description = "Safe, consistent, and easy exception handling";
···
        pname = "safe-json";
        version = "1.1.0";
        sha256 = "18zsf2dccgf755a8g4ar3zc7ilmampsrvqa6f9p27zrayl7j87hw";
-       revision = "3";
-       editedCabalFile = "12jjph25vffkj55ds468zv144qxwyrb6qmp2g1pb03732n6z9596";
+       revision = "4";
+       editedCabalFile = "12z5z68bfrzv3laagbssdcv7g97bpk2wf1bjirrivbhdbslf6l4q";
        libraryHaskellDepends = [
          aeson base bytestring containers dlist hashable scientific tasty
          tasty-hunit tasty-quickcheck text time unordered-containers
···
 
   "semantic-source" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, deepseq
-     , doctest, generic-monoid, hashable, hedgehog, lingo, pathtype
-     , QuickCheck, semilattices, tasty, tasty-hedgehog, tasty-hunit
-     , text
+     , hashable, hedgehog, lingo, pathtype, semilattices, tasty
+     , tasty-hedgehog, tasty-hunit, text
      }:
      mkDerivation {
        pname = "semantic-source";
-       version = "0.1.0.0";
-       sha256 = "179rxsn1cyh77yn7vzmii38ipgcjpavlyf5xbx4j8zzgh1jklmc5";
+       version = "0.1.0.1";
+       sha256 = "1v4q9yc91lrx02wdhxp1njzm8g9qlwr40593lwcn6bxlad5sk6yd";
        libraryHaskellDepends = [
-         aeson base bytestring containers deepseq generic-monoid hashable
-         lingo pathtype semilattices text
+         aeson base bytestring containers deepseq hashable lingo pathtype
+         semilattices text
        ];
        testHaskellDepends = [
-         base doctest hedgehog QuickCheck tasty tasty-hedgehog tasty-hunit
-         text
+         base hedgehog tasty tasty-hedgehog tasty-hunit text
        ];
        description = "Types and functionality for working with source code";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "servant-lucid_0_9_0_1" = callPackage
+  "servant-lucid_0_9_0_2" = callPackage
     ({ mkDerivation, base, http-media, lucid, servant, servant-server
      , text, wai, warp
      }:
      mkDerivation {
        pname = "servant-lucid";
-       version = "0.9.0.1";
-       sha256 = "1jhs9qy36vccy90s24cd9bmhqs604xqd9m8a4fbkjxrcpgdzfjgq";
+       version = "0.9.0.2";
+       sha256 = "0l68dffx746j3p2l5x59cj5cdng2dw6vjq5x5h44m0ccbsmlckpz";
        libraryHaskellDepends = [ base http-media lucid servant text ];
        testHaskellDepends = [ base lucid servant-server wai warp ];
        description = "Servant support for lucid";
···
      }:
      mkDerivation {
        pname = "servant-reflex";
-       version = "0.3.4";
-       sha256 = "1k7dkzs2lsdjj94ai7p225zm09l9sgbxpb4av14xgy9m54rih5kk";
+       version = "0.3.5";
+       sha256 = "0b4ppjnfas6pwypd16vkq98q1fs0l7cw32hhliv582xfvc0v3k8l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "servant-static-th";
-       version = "0.2.3.0";
-       sha256 = "0gyfjrrq7anhn4b613gnaa0r2xm8rkminx1nrrbpn6bw47axadj4";
+       version = "0.2.4.0";
+       sha256 = "1xmikym19kq912apmh6zcdjzbz23mhn580pvsy5ll35ylqziaflk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "shake-dhall";
-       version = "0.1.1.2";
-       sha256 = "0jlbq9d6sjrbywd0afgsqqw1ffjlh5k4mr5v2bn45js29hipkivk";
+       version = "0.1.1.3";
+       sha256 = "1crakjnib9hvqph8f0wn0ii0y4hp9vix40kd8fpz85mdqfsynf5q";
        libraryHaskellDepends = [
          base containers dhall directory filepath shake text
        ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Dhall dependencies";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "shake-elm" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "shake-plus_0_3_2_0" = callPackage
+  "shake-plus_0_3_3_0" = callPackage
     ({ mkDerivation, base, extra, path, rio, shake }:
      mkDerivation {
        pname = "shake-plus";
-       version = "0.3.2.0";
-       sha256 = "0cgn1hgxp3kly7yp4s8mx714p1gnf30jpp6vjl47l19vc21hfzj5";
+       version = "0.3.3.0";
+       sha256 = "13a5n6gh1msrygi671lk5y83shcd75yz64x3r2smxif5hsfazwqv";
        libraryHaskellDepends = [ base extra path rio shake ];
        description = "Re-export of Shake using well-typed paths and ReaderT";
        license = stdenv.lib.licenses.mit;
···
      }) {};
 
   "shake-plus-extended" = callPackage
-    ({ mkDerivation, base, comonad, extra, ixset-typed
-     , ixset-typed-binary-instance, ixset-typed-hashable-instance, path
-     , path-binary-instance, rio, shake, shake-plus, within
+    ({ mkDerivation, aeson, base, binary-instances, comonad, extra
+     , http-conduit, ixset-typed, ixset-typed-binary-instance
+     , ixset-typed-hashable-instance, path, path-binary-instance, rio
+     , shake, shake-plus, within
      }:
      mkDerivation {
        pname = "shake-plus-extended";
-       version = "0.3.0.0";
-       sha256 = "040g0h0a03wmwhbqn06jxwf5h0lwsiqfa1x1x9wzyw8m52f5ngn4";
+       version = "0.4.0.0";
+       sha256 = "1y12hcsyp8slzacjz8dim64m9sr09z7ppv3s4l30wyha9r395x8i";
        libraryHaskellDepends = [
-         base comonad extra ixset-typed ixset-typed-binary-instance
-         ixset-typed-hashable-instance path path-binary-instance rio shake
-         shake-plus within
+         aeson base binary-instances comonad extra http-conduit ixset-typed
+         ixset-typed-binary-instance ixset-typed-hashable-instance path
+         path-binary-instance rio shake shake-plus within
        ];
        description = "Experimental extensions to shake-plus";
        license = stdenv.lib.licenses.mit;
···
        ];
        description = "A toolkit for making compile-time interpolated templates";
        license = stdenv.lib.licenses.mit;
+       maintainers = with stdenv.lib.maintainers; [ psibi ];
+     }) {};
+
+  "shakespeare_2_0_25" = callPackage
+    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
+     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
+     , process, scientific, template-haskell, text, th-lift, time
+     , transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "shakespeare";
+       version = "2.0.25";
+       sha256 = "1fjv3yg425d87d3dih0l3ff95g5a5yp9w85m58sjara6xqivj9s4";
+       libraryHaskellDepends = [
+         aeson base blaze-html blaze-markup bytestring containers directory
+         exceptions ghc-prim parsec process scientific template-haskell text
+         th-lift time transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base blaze-html blaze-markup bytestring containers directory
+         exceptions ghc-prim hspec HUnit parsec process template-haskell
+         text time transformers
+       ];
+       description = "A toolkit for making compile-time interpolated templates";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
        maintainers = with stdenv.lib.maintainers; [ psibi ];
      }) {};
 
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "shelly_1_8_1" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, directory
+     , enclosed-exceptions, exceptions, filepath, hspec, hspec-contrib
+     , HUnit, lifted-async, lifted-base, monad-control, mtl, process
+     , system-fileio, system-filepath, text, time, transformers
+     , transformers-base, unix, unix-compat
+     }:
+     mkDerivation {
+       pname = "shelly";
+       version = "1.8.1";
+       sha256 = "023fbvbqs5gdwm30j5517gbdcc7fvz0md70dgwgpypkskj3i926y";
+       revision = "1";
+       editedCabalFile = "0crf0m077wky76f5nav2p9q4fa5q4yhv5l4bq9hd073dzdaywhz0";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async base bytestring containers directory enclosed-exceptions
+         exceptions lifted-async lifted-base monad-control mtl process
+         system-fileio system-filepath text time transformers
+         transformers-base unix unix-compat
+       ];
+       testHaskellDepends = [
+         async base bytestring containers directory enclosed-exceptions
+         exceptions filepath hspec hspec-contrib HUnit lifted-async
+         lifted-base monad-control mtl process system-fileio system-filepath
+         text time transformers transformers-base unix unix-compat
+       ];
+       description = "shell-like (systems) programming in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "shelly" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, directory
      , enclosed-exceptions, exceptions, filepath, hspec, hspec-contrib
···
   "souffle-haskell" = callPackage
     ({ mkDerivation, array, base, containers, deepseq, directory, extra
      , filepath, hedgehog, hspec, hspec-hedgehog, megaparsec, mtl
-     , process, template-haskell, temporary, text, type-errors-pretty
-     , vector
+     , neat-interpolation, process, template-haskell, temporary, text
+     , type-errors-pretty, vector
      }:
      mkDerivation {
        pname = "souffle-haskell";
-       version = "1.1.0";
-       sha256 = "0s8zl7f6v89m6a3yhlmji1lb8k3rfwzyyg307m3f35a9kms0988p";
+       version = "2.0.0";
+       sha256 = "0x6v1g5in762w1hhwcg5ipa0c491wp0mflqljjpl99da6kr1l93f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         array base deepseq directory filepath mtl process template-haskell
-         temporary text type-errors-pretty vector
+         array base containers deepseq directory filepath mtl process
+         template-haskell temporary text type-errors-pretty vector
        ];
        executableHaskellDepends = [
          array base containers deepseq directory extra filepath megaparsec
···
          vector
        ];
        testHaskellDepends = [
-         array base deepseq directory filepath hedgehog hspec hspec-hedgehog
-         mtl process template-haskell temporary text type-errors-pretty
-         vector
+         array base containers deepseq directory filepath hedgehog hspec
+         hspec-hedgehog mtl neat-interpolation process template-haskell
+         temporary text type-errors-pretty vector
        ];
        description = "Souffle Datalog bindings for Haskell";
        license = stdenv.lib.licenses.mit;
···
        ];
        description = "Unified streaming data-dependency framework for web apps";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "spars" = callPackage
+    ({ mkDerivation, base, containers }:
+     mkDerivation {
+       pname = "spars";
+       version = "0.1.0.0";
+       sha256 = "1q1vpwrr96k41p9zj5x7mjd3817iq9a762q3jfqkwd0cb41iyka6";
+       libraryHaskellDepends = [ base containers ];
+       description = "A sparse set-based parsing library for Haskell";
+       license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
        broken = true;
      }) {};
 
+  "supernova" = callPackage
+    ({ mkDerivation, aeson, async, base, bifunctor, binary, bytestring
+     , Cabal, crc32c, exceptions, lens-family-core, logging, managed
+     , network, proto-lens, proto-lens-runtime, proto-lens-setup
+     , streamly, text, unliftio
+     }:
+     mkDerivation {
+       pname = "supernova";
+       version = "0.0.1";
+       sha256 = "0v0x1xk63kxrf2ihhdr24z7ami557d3w2zizd0g8xqp02pr5gs8z";
+       setupHaskellDepends = [ base Cabal proto-lens-setup ];
+       libraryHaskellDepends = [
+         base bifunctor binary bytestring crc32c exceptions lens-family-core
+         logging managed network proto-lens proto-lens-runtime text unliftio
+       ];
+       testHaskellDepends = [ aeson async base bytestring streamly text ];
+       description = "Apache Pulsar client for Haskell";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "supero" = callPackage
     ({ mkDerivation, base, containers, cpphs, directory, filepath
      , haskell-src-exts, mtl, process, time, uniplate
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "template-haskell-compat-v0208_0_1_4" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "template-haskell-compat-v0208";
+       version = "0.1.4";
+       sha256 = "0byc81m07v5a765vs4jpwgmgkf54c2n5yaqz8ava1sspmmf2p9fh";
+       libraryHaskellDepends = [ base template-haskell ];
+       description = "A backwards compatibility layer for Template Haskell newer than 2.8";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "template-haskell-util" = callPackage
     ({ mkDerivation, base, GenericPretty, ghc-prim, template-haskell }:
      mkDerivation {
···
        ];
        description = "Terminal emulator configurable in Haskell";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) gtk3; inherit (pkgs) pcre2; 
          vte_291 = pkgs.vte;};
 
···
        pname = "token-bucket";
        version = "0.1.0.1";
        sha256 = "1l3axqdkrjf28pxhrvdvlpf9wi79czsfvhi33w4v2wbj0g00j9ii";
-       revision = "5";
-       editedCabalFile = "049d9bk5f8qa6d7gjgg4nqd56xz1mrxr1rxcwxsrk4vkqcpmzs6q";
+       revision = "6";
+       editedCabalFile = "15p4iycphz4q58kgq00kmz0ik0hzv3vx47k2dkp93xavb0dny46v";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base time ];
        description = "Rate limiter using lazy bucket algorithm";
···
        pname = "tree-diff";
        version = "0.1";
        sha256 = "1156nbqn0pn9lp4zjsy4vv5g5wmy4zxwmbqdgvq349rydynh3ng3";
-       revision = "4";
-       editedCabalFile = "0zl94ppd94szvmqa7vnpbcr2zfppbqm4k6isidzks2mz2ji9dc1i";
+       revision = "5";
+       editedCabalFile = "1b60x9cgp7hn42hc97q866ybhg5hx3sp45j6gngpbwryg29r2p4h";
        libraryHaskellDepends = [
          aeson ansi-terminal ansi-wl-pprint base base-compat bytestring
          bytestring-builder containers hashable parsec parsers pretty
···
      }:
      mkDerivation {
        pname = "twirp";
-       version = "0.2.0.0";
-       sha256 = "00dc6bil998fdvb5p0r2782cy3nknw6s8k5a0cv4yqmha4iyn32m";
+       version = "0.2.0.1";
+       sha256 = "05np0zvnvy8wrm9lirrkwhd0n8f44j4xwr6lrywxxy9r00mx8bbl";
        libraryHaskellDepends = [
          aeson base bytestring http-media http-types proto-lens
          proto-lens-jsonpb proto-lens-runtime servant text wai
···
      }) {};
 
   "unicode-transforms" = callPackage
-    ({ mkDerivation, base, bitarray, bytestring, deepseq, filepath
-     , gauge, getopt-generics, optparse-applicative, path, path-io
-     , QuickCheck, split, text
-     }:
-     mkDerivation {
-       pname = "unicode-transforms";
-       version = "0.3.6";
-       sha256 = "1akscvyssif4hki3g6hy0jmjyr8cqly1whzvzj0km2b3qh0x09l3";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base bitarray bytestring text ];
-       testHaskellDepends = [
-         base deepseq getopt-generics QuickCheck split text
-       ];
-       benchmarkHaskellDepends = [
-         base deepseq filepath gauge optparse-applicative path path-io text
-       ];
-       description = "Unicode normalization";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "unicode-transforms_0_3_7" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, filepath, gauge
      , getopt-generics, ghc-prim, hspec, path, path-io, QuickCheck
      , split, text
···
        ];
        description = "Unicode normalization";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "unicode-tricks" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "universum_1_7_0" = callPackage
+  "universum_1_7_1" = callPackage
     ({ mkDerivation, base, bytestring, containers, deepseq, doctest
      , gauge, ghc-prim, Glob, hashable, hedgehog, microlens
      , microlens-mtl, mtl, safe-exceptions, stm, tasty, tasty-hedgehog
···
      }:
      mkDerivation {
        pname = "universum";
-       version = "1.7.0";
-       sha256 = "079sck4cfhvx4zda5qiz7vs3050l87ik9hx8yjc6bihrzlqvmgfb";
+       version = "1.7.1";
+       sha256 = "0jsdzhy0h5d6znnrdgzr29b6qkriidck5s6yp52pci30rfv1d29z";
        libraryHaskellDepends = [
          base bytestring containers deepseq ghc-prim hashable microlens
          microlens-mtl mtl safe-exceptions stm text transformers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "url-bytes" = callPackage
+    ({ mkDerivation, base, byteslice, bytesmith, bytestring, deepseq
+     , gauge, HUnit, primitive, tasty, tasty-hunit, template-haskell
+     , uri-bytestring, weigh
+     }:
+     mkDerivation {
+       pname = "url-bytes";
+       version = "0.1.0.0";
+       sha256 = "0nbxnmz1m2icg3vvdndr4zydwr8nbgxhb70ak2jzc6d92c3vhvqi";
+       libraryHaskellDepends = [
+         base byteslice bytesmith primitive template-haskell
+       ];
+       testHaskellDepends = [
+         base byteslice HUnit primitive tasty tasty-hunit
+       ];
+       benchmarkHaskellDepends = [
+         base byteslice bytestring deepseq gauge primitive uri-bytestring
+         weigh
+       ];
+       description = "Memory efficient url type and parser";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "url-decoders" = callPackage
     ({ mkDerivation, base, base-prelude, binary-parser, bytestring
      , criterion, http-types, QuickCheck, quickcheck-instances, rerebase
···
      }:
      mkDerivation {
        pname = "vector-sized";
-       version = "1.4.1.0";
-       sha256 = "14l6c8l8l29f6kdffknd70kkccfjcf105i1zd0kchgsgjnr9p6l1";
-       libraryHaskellDepends = [
-         adjunctions base binary comonad deepseq distributive
-         finite-typelits hashable indexed-list-literals primitive vector
-       ];
-       description = "Size tagged vectors";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "vector-sized_1_4_2" = callPackage
-    ({ mkDerivation, adjunctions, base, binary, comonad, deepseq
-     , distributive, finite-typelits, hashable, indexed-list-literals
-     , primitive, vector
-     }:
-     mkDerivation {
-       pname = "vector-sized";
        version = "1.4.2";
        sha256 = "02a7jzik6a6w1xb6bwpvl6hmii6jgi9wr0q7p48bfbq0mlqjv42h";
        libraryHaskellDepends = [
···
        ];
        description = "Size tagged vectors";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "vector-space" = callPackage
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.6.5";
-       sha256 = "17r0rn2xs5l5x9vwa5vyc4q11gyw2v29qs7vqicla0qb4hh140fj";
+       version = "3.6.6";
+       sha256 = "09mq11jqrd9sgx4xcy3xxji21yfhzl9a49mh5fp80y2mxsxdl0v9";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        librarySystemDepends = [ vulkan ];
        description = "Bindings to the Vulkan graphics API";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "within_0_2_0_0" = callPackage
+  "within_0_2_0_1" = callPackage
     ({ mkDerivation, base, comonad, exceptions, free, hashable, path
      , path-like
      }:
      mkDerivation {
        pname = "within";
-       version = "0.2.0.0";
-       sha256 = "1jvfxcxyavadcbslb50a6ad7bmnwz45d6zaxyc38y61kh0r82242";
+       version = "0.2.0.1";
+       sha256 = "1yzfzizx45ngvvbshgw9z8hxl8z7vcr1gann6wnxq4b9669h29ic";
        libraryHaskellDepends = [
          base comonad exceptions free hashable path path-like
        ];
···
      }:
      mkDerivation {
        pname = "xmobar";
-       version = "0.35.1";
-       sha256 = "1fizszhij2if9wxwzi728l93j9p5y9kfqnwnxk6nl66g64rsbp5x";
+       version = "0.36";
+       sha256 = "0kqnadgsqn7m3zw2vk22ssf4aw67rij9l1lpjfsnv2qw0m5apsdl";
        configureFlags = [
          "-fwith_alsa" "-fwith_conduit" "-fwith_datezone" "-fwith_dbus"
          "-fwith_inotify" "-fwith_iwlib" "-fwith_mpd" "-fwith_mpris"
···
      }:
      mkDerivation {
        pname = "yaml";
-       version = "0.11.4.0";
-       sha256 = "0v69d10ni6ydj4g63ajcmnx6a2j3kbl91vpz678l7k5mkd3chkns";
-       configureFlags = [ "-fsystem-libyaml" ];
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson attoparsec base bytestring conduit containers directory
-         filepath libyaml mtl resourcet scientific template-haskell text
-         transformers unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson attoparsec base base-compat bytestring conduit containers
-         directory filepath hspec HUnit libyaml mockery mtl raw-strings-qq
-         resourcet scientific template-haskell temporary text transformers
-         unordered-containers vector
-       ];
-       description = "Support for parsing and rendering YAML documents";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "yaml_0_11_5_0" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
-     , conduit, containers, directory, filepath, hspec, HUnit, libyaml
-     , mockery, mtl, raw-strings-qq, resourcet, scientific
-     , template-haskell, temporary, text, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "yaml";
        version = "0.11.5.0";
        sha256 = "1bfdsqckzql50j6ni4fa1470cvkmfiy4skb98cdwnj4rss5p93mj";
        configureFlags = [ "-fsystem-libyaml" ];
···
        ];
        description = "Support for parsing and rendering YAML documents";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yaml-combinators" = callPackage
···
      }) {};
 
   "yhseq" = callPackage
-    ({ mkDerivation, base, hspec, hspec-discover }:
+    ({ mkDerivation, base, containers, hspec, hspec-discover, vector }:
      mkDerivation {
        pname = "yhseq";
-       version = "0.2.1.2";
-       sha256 = "1mxjfbnic6pn4jnyc83afpmgq4wnb09f72d359pwx693mfi6vbiy";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ base hspec hspec-discover ];
+       version = "0.3.0.1";
+       sha256 = "1daipppqia4ig7xa9wxy2g3gcxrcwhxm1g6j5l81v56vfh0smg9r";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base containers vector ];
+       executableHaskellDepends = [ base containers vector ];
+       testHaskellDepends = [
+         base containers hspec hspec-discover vector
+       ];
        testToolDepends = [ hspec-discover ];
-       description = "Calculation of Y-sequence Hexirp edition";
+       description = "Calculation of YH sequence system";
        license = stdenv.lib.licenses.asl20;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "zenacy-html";
-       version = "2.0.1";
-       sha256 = "074iidhiwzajz207q4k7f8sdg6w4421qfwr2s905226jd2xm1680";
+       version = "2.0.2";
+       sha256 = "12m953skm4ms6y211ahjrr6gkmrh4p3h2snpcpg1fc039nxgkc9p";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          raw-strings-qq text
        ];
        description = "A standard compliant HTML parsing library";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "zenacy-unicode" = callPackage
+    ({ mkDerivation, base, bytestring, HUnit, test-framework
+     , test-framework-hunit, text, vector, word8
+     }:
+     mkDerivation {
+       pname = "zenacy-unicode";
+       version = "1.0.0";
+       sha256 = "03sksmmmn380nvh0f139g63b4yx42ziimv79xjja7yx6mhaa0pqf";
+       libraryHaskellDepends = [ base bytestring vector word8 ];
+       testHaskellDepends = [
+         base bytestring HUnit test-framework test-framework-hunit text
+       ];
+       description = "Unicode utilities for Haskell";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "zipper-extra";
-       version = "0.1.3.1";
-       sha256 = "1n6amxaydfannxhgnbj5g315m96h5wvgrdw89n6761vii76csky4";
+       version = "0.1.3.2";
+       sha256 = "0cq21hf40qp025ir9kihsp6b09bsrlgiqd5cfq688w57c2vhcmci";
        libraryHaskellDepends = [
          base comonad comonad-extras exceptions split
        ];

pkgs/development/tools/haskell/haskell-language-server/hls-ghcide.nix

···
   version = "0.2.0";
   src = fetchgit {
     url = "https://github.com/wz1000/ghcide";
-    sha256 = "1zq7ngaak8il91a309rl51dghzasnk4m2sm3av6d93cyqyra1hfc";
-    rev = "078e3d3c0d319f83841ccbcdc60ff5f0e243f6be";
+    sha256 = "112bsk2660750n94gnsgrvd30rk0ccxb8dbhka606a11pcqv5cgx";
+    rev = "3f6cd4553279ec47d1599b502720791a4f4613cd";
     fetchSubmodules = true;
   };
   isLibrary = true;