Merge pull request #94872 from NixOS/haskell-updates

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

pkgs/development/compilers/ghc/8.10.1.nix

···
   enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
 
   # aarch64 outputs otherwise exceed 2GB limit
-, enableProfiliedLibs ? !stdenv.targetPlatform.isAarch64
+, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
 
 , # Whether to build dynamic libs for the standard library (on the target
   # platform). Static libs are always built.
···
     HADDOCK_DOCS = NO
     BUILD_SPHINX_HTML = NO
     BUILD_SPHINX_PDF = NO
-  '' + stdenv.lib.optionalString (!enableProfiliedLibs) ''
+  '' + stdenv.lib.optionalString (!enableProfiledLibs) ''
     GhcLibWays = "v dyn"
   '' + stdenv.lib.optionalString enableRelocatedStaticLibs ''
     GhcLibHcOpts += -fPIC

pkgs/development/compilers/ghc/8.8.3.nix

···
 , # If enabled, use -fPIC when compiling static libs.
   enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
 
+  # aarch64 outputs otherwise exceed 2GB limit
+, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
+
 , # Whether to build dynamic libs for the standard library (on the target
   # platform). Static libs are always built.
   enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt
 
 , # Whether to build terminfo.
   enableTerminfo ? !stdenv.targetPlatform.isWindows
-
-  # aarch64 outputs otherwise exceed 2GB limit
-, enableProfiliedLibs ? !stdenv.targetPlatform.isAarch64
 
 , # What flavour to build. An empty string indicates no
   # specific flavour and falls back to ghc default values.
···
     HADDOCK_DOCS = NO
     BUILD_SPHINX_HTML = NO
     BUILD_SPHINX_PDF = NO
-  '' + stdenv.lib.optionalString (!enableProfiliedLibs) ''
+  '' + stdenv.lib.optionalString (!enableProfiledLibs) ''
     GhcLibWays = "v dyn"
   '' + stdenv.lib.optionalString enableRelocatedStaticLibs ''
     GhcLibHcOpts += -fPIC

pkgs/development/compilers/ghc/8.8.4.nix

···
   enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
 
   # aarch64 outputs otherwise exceed 2GB limit
-, enableProfiliedLibs ? !stdenv.targetPlatform.isAarch64
+, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
 
 , # Whether to build dynamic libs for the standard library (on the target
   # platform). Static libs are always built.
···
     HADDOCK_DOCS = NO
     BUILD_SPHINX_HTML = NO
     BUILD_SPHINX_PDF = NO
-  '' + stdenv.lib.optionalString (!enableProfiliedLibs) ''
+  '' + stdenv.lib.optionalString (!enableProfiledLibs) ''
     GhcLibWays = "v dyn"
   '' + stdenv.lib.optionalString enableRelocatedStaticLibs ''
     GhcLibHcOpts += -fPIC

pkgs/development/compilers/ghc/head.nix

···
   # build-time dependency too.
   buildLlvmPackages, llvmPackages
 
-, # If enabled, GHC will be built with the GPL-free but slower integer-simple
-  # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(stdenv.lib.any (stdenv.lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms)
+, # If enabled, GHC will be built with the GPL-free but slightly slower native
+  # bignum backend instead of the faster but GPLed gmp backend.
+  enableNativeBignum ? !(stdenv.lib.any (stdenv.lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms)
 , gmp
 
 , # If enabled, use -fPIC when compiling static libs.
···
 , # Whether to build terminfo.
   enableTerminfo ? !stdenv.targetPlatform.isWindows
 
-, version ? "8.11.20200505"
+, version ? "8.11.20200731"
 , # 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)
···
   disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64
 }:
 
-assert !enableIntegerSimple -> gmp != null;
+assert !enableNativeBignum -> gmp != null;
 
 let
   inherit (stdenv) buildPlatform hostPlatform targetPlatform;
···
     include mk/flavours/\$(BuildFlavour).mk
     endif
     DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
-    INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
+    BIGNUM_BACKEND = ${if enableNativeBignum then "native" else "gmp"}
   '' + stdenv.lib.optionalString (targetPlatform != hostPlatform) ''
     Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}
     CrossCompilePrefix = ${targetPrefix}
···
   # Splicer will pull out correct variations
   libDeps = platform: stdenv.lib.optional enableTerminfo ncurses
     ++ [libffi]
-    ++ stdenv.lib.optional (!enableIntegerSimple) gmp
+    ++ stdenv.lib.optional (!enableNativeBignum) gmp
     ++ stdenv.lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv
     ++ stdenv.lib.optional enableDwarf elfutils;
 
···
 
   src = fetchgit {
     url = "https://gitlab.haskell.org/ghc/ghc.git/";
-    rev = "40c71c2cf38b4e134d81b7184a4d5e02949ae70c";
-    sha256 = "04h9rcyzm9w3an1z00hjs062dp7dl19b8pkyxjsypr7a2i9dmvkb";
+    rev = "380638a33691ba43fdcd2e18bca636750e5f66f1";
+    sha256 = "029cgiyhddvwnx5zx31i0vgj13zsvzb8fna99zr6ifscz6x7rid1";
   };
 
   enableParallelBuilding = true;
···
     "--with-system-libffi"
     "--with-ffi-includes=${targetPackages.libffi.dev}/include"
     "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
-  ] ++ stdenv.lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
+  ] ++ stdenv.lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [
     "--with-gmp-includes=${targetPackages.gmp.dev}/include"
     "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
   ] ++ stdenv.lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [

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

···
         })).override {
           # we are faster than stack here
           hie-bios = dontCheck self.hie-bios_0_6_1;
-          lsp-test = dontCheck self.lsp-test_0_11_0_3;
+          lsp-test = dontCheck self.lsp-test_0_11_0_4;
         });
 
   haskell-language-server = (overrideCabal super.haskell-language-server
···
       ghcide = self.hls-ghcide;
       # we are faster than stack here
       hie-bios = dontCheck self.hie-bios_0_6_1;
-      lsp-test = dontCheck self.lsp-test_0_11_0_3;
+      lsp-test = dontCheck self.lsp-test_0_11_0_4;
     };
 
   # https://github.com/kowainik/policeman/issues/57

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

···
   unliftio-core = doJailbreak super.unliftio-core;
 
   # Use the latest version to fix the build.
-  dhall = self.dhall_1_33_1;
+  dhall = self.dhall_1_34_0;
   lens = self.lens_4_19_2;
-  optics-core = self.optics-core_0_3;
+  optics-core = self.optics-core_0_3_0_1;
   repline = self.repline_0_4_0_0;
   singletons = self.singletons_2_7;
   th-desugar = self.th-desugar_1_11;

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

···
   filepath = null;
   ghc-boot = null;
   ghc-boot-th = null;
+  ghc-bignum = null;
   ghc-compact = null;
   ghc-heap = null;
   ghci = null;

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

···
   # gi-gdkx11-4.x requires gtk-4.x, which is still under development and
   # not yet available in Nixpkgs
   - gi-gdkx11 < 4
-  # LTS Haskell 16.7
+  # LTS Haskell 16.8
   - abstract-deque ==0.3
   - abstract-par ==0.3.3
   - AC-Angle ==1.0
···
   - bins ==0.1.2.0
   - bitarray ==0.0.1.1
   - bits ==0.5.2
-  - bitset-word8 ==0.1.1.1
+  - bitset-word8 ==0.1.1.2
   - bits-extra ==0.0.2.0
   - bitvec ==1.0.3.0
   - blake2 ==0.3.0
···
   - cipher-des ==0.0.6
   - cipher-rc4 ==0.1.4
   - circle-packing ==0.1.0.6
-  - clash-ghc ==1.2.3
-  - clash-lib ==1.2.3
-  - clash-prelude ==1.2.3
+  - clash-ghc ==1.2.4
+  - clash-lib ==1.2.4
+  - clash-prelude ==1.2.4
   - classy-prelude ==1.5.0
   - classy-prelude-conduit ==1.5.0
   - classy-prelude-yesod ==1.5.0
···
   - control-monad-omega ==0.3.2
   - convertible ==1.1.1.0
   - cookie ==0.4.5
-  - core-data ==0.2.1.5
-  - core-program ==0.2.4.2
-  - core-text ==0.2.3.3
+  - core-data ==0.2.1.7
+  - core-program ==0.2.4.4
+  - core-text ==0.2.3.5
   - countable ==1.0
   - cpio-conduit ==0.7.0
   - cpphs ==1.20.9.1
···
   - file-path-th ==0.1.0.0
   - filepattern ==0.1.2
   - fileplow ==0.1.0.0
-  - filtrable ==0.1.3.0
+  - filtrable ==0.1.4.0
   - fin ==0.1.1
   - FindBin ==0.0.5
   - fingertree ==0.1.4.2
···
   - hadoop-streaming ==0.2.0.3
   - hakyll ==4.13.4.0
   - half ==0.3
+  - hall-symbols ==0.1.0.6
   - hamtsolo ==1.0.3
   - HandsomeSoup ==0.4.2
   - hapistrano ==0.4.1.0
···
   - hint ==0.9.0.3
   - hjsmin ==0.2.0.4
   - hkd-default ==1.1.0.0
-  - hkgr ==0.2.6
+  - hkgr ==0.2.6.1
   - hlibcpuid ==0.2.0
   - hlibgit2 ==0.18.0.16
   - hmatrix ==0.20.0.0
···
   - http-link-header ==1.0.3.1
   - http-media ==0.8.0.0
   - http-reverse-proxy ==0.6.0
-  - http-streams ==0.8.7.1
+  - http-streams ==0.8.7.2
   - http-types ==0.12.3
   - human-readable-duration ==0.2.1.4
   - HUnit ==1.6.0.0
···
   - MusicBrainz ==0.4.1
   - mustache ==2.3.1
   - mutable-containers ==0.3.4
-  - mwc-probability ==2.3.0
+  - mwc-probability ==2.3.1
   - mwc-random ==0.14.0.0
   - mx-state-codes ==1.0.0.0
   - mysql ==0.1.7
···
   - pretty-class ==1.0.1.1
   - pretty-hex ==1.1
   - prettyprinter ==1.6.2
-  - prettyprinter-ansi-terminal ==1.1.1.2
+  - prettyprinter-ansi-terminal ==1.1.2
   - prettyprinter-compat-annotated-wl-pprint ==1
   - prettyprinter-compat-ansi-wl-pprint ==1.0.1
   - prettyprinter-compat-wl-pprint ==1.0.0.1
-  - prettyprinter-convert-ansi-wl-pprint ==1.1
+  - prettyprinter-convert-ansi-wl-pprint ==1.1.1
   - pretty-relative-time ==0.2.0.0
   - pretty-show ==1.10
   - pretty-simple ==3.2.3.0
···
   - rawstring-qm ==0.2.3.0
   - raw-strings-qq ==1.1
   - rcu ==0.2.4
-  - rdf ==0.1.0.3
+  - rdf ==0.1.0.4
   - rdtsc ==1.3.0.1
   - re2 ==0.3
   - readable ==0.3.1
···
   - salve ==1.0.10
   - sample-frame ==0.0.3
   - sample-frame-np ==0.0.4.1
-  - sampling ==0.3.4
+  - sampling ==0.3.5
   - say ==0.1.0.1
   - sbp ==2.6.3
   - scalpel ==0.6.2
···
   - syb ==0.7.1
   - symbol ==0.2.4
   - symengine ==0.1.2.0
+  - symmetry-operations-symbols ==0.0.1.4
   - sysinfo ==0.1.1
   - system-argv0 ==0.1.1
   - systemd ==2.3.0
···
   - th-nowq ==0.1.0.5
   - th-orphans ==0.13.10
   - th-printf ==0.7
-  - thread-hierarchy ==0.3.0.1
+  - thread-hierarchy ==0.3.0.2
   - thread-local-storage ==0.2
   - threads ==0.5.1.6
-  - thread-supervisor ==0.1.0.0
+  - thread-supervisor ==0.1.0.1
   - threepenny-gui ==0.9.0.0
   - th-reify-compat ==0.0.1.5
   - th-reify-many ==0.1.9
···
   - wave ==0.2.0
   - wcwidth ==0.0.2
   - webdriver ==0.9.0.1
-  - webex-teams-api ==0.2.0.0
-  - webex-teams-conduit ==0.2.0.0
-  - webex-teams-pipes ==0.2.0.0
+  - webex-teams-api ==0.2.0.1
+  - webex-teams-conduit ==0.2.0.1
+  - webex-teams-pipes ==0.2.0.1
   - webrtc-vad ==0.1.0.3
   - websockets ==0.12.7.1
   - websockets-snap ==0.10.3.1
···
   - chart-histogram
   - Chart-simple
   - chart-svg
+  - chart-svg-various
   - chart-unit
   - chatter
   - chatty-text
···
   - mDNSResponder-client
   - mdp
   - mealstrom
+  - mealy
   - MeanShift
   - Measure
   - mecab
···
   - postgresql-simple-sop
   - postgresql-simple-typed
   - postgresql-syntax
+  - postgresql-tx-query
+  - postgresql-tx-squeal
   - postgresql-typed
   - postgresql-typed-lifted
   - postgrest-ws
···
   - SCalendar
   - scalendar
   - scalp-webhooks
+  - scalpel-search
   - scan-vector-machine
   - scc
   - scenegraph
···
   - taskell
   - TaskMonad
   - tasty-auto
+  - tasty-bdd
   - tasty-fail-fast
   - tasty-groundhog-converters
   - tasty-hedgehog-coverage

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

···
        pname = "BNFC-meta";
        version = "0.6.1";
        sha256 = "0snackflcjxza4iqbd85fdsmylwr3bj71nsfrs2s2idc3nlxc7ia";
+       revision = "1";
+       editedCabalFile = "1lj92qxjf7gbgifhz1p6jw20079x6772gkbhvpd8ba4956dvzna3";
        libraryHaskellDepends = [
          alex-meta array base fail happy-meta haskell-src-meta syb
          template-haskell
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "VulkanMemoryAllocator";
-       version = "0.3.5";
-       sha256 = "1j8xnb29ad172qjfrnd4mc4v5a4bfd6ka8xadfknb2d5a5d7r5nn";
+       version = "0.3.6";
+       sha256 = "1zclpawaa1cx1p58asn7lla4lakkr869qnkdvrypxxqki3406hsz";
        libraryHaskellDepends = [
          base bytestring transformers vector vulkan
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "aeson_1_5_2_0" = callPackage
+  "aeson_1_5_3_0" = callPackage
     ({ mkDerivation, attoparsec, base, base-compat
      , base-compat-batteries, base-orphans, base16-bytestring
-     , bytestring, containers, deepseq, Diff, directory, dlist, filepath
-     , generic-deriving, ghc-prim, hashable, hashable-time
+     , bytestring, containers, data-fix, deepseq, Diff, directory, dlist
+     , filepath, generic-deriving, ghc-prim, hashable, hashable-time
      , integer-logarithms, primitive, QuickCheck, quickcheck-instances
-     , scientific, tagged, tasty, tasty-golden, tasty-hunit
+     , scientific, strict, tagged, tasty, tasty-golden, tasty-hunit
      , tasty-quickcheck, template-haskell, text, th-abstraction, these
      , time, time-compat, unordered-containers, uuid-types, vector
      }:
      mkDerivation {
        pname = "aeson";
-       version = "1.5.2.0";
-       sha256 = "0awk3dss79mmcxpy147mijnd9icvlnm77bq248ibbbzx9y99hdfd";
+       version = "1.5.3.0";
+       sha256 = "0slqxmm4rikndzq2rmgydaqgf9qqnni62bgr0zihf25d65mgk3lm";
        libraryHaskellDepends = [
-         attoparsec base base-compat-batteries bytestring containers deepseq
-         dlist ghc-prim hashable primitive scientific tagged
-         template-haskell text th-abstraction these time time-compat
-         unordered-containers uuid-types vector
+         attoparsec base base-compat-batteries bytestring containers
+         data-fix deepseq dlist ghc-prim hashable primitive scientific
+         strict tagged template-haskell text th-abstraction these time
+         time-compat unordered-containers uuid-types vector
        ];
        testHaskellDepends = [
          attoparsec base base-compat base-orphans base16-bytestring
-         bytestring containers Diff directory dlist filepath
+         bytestring containers data-fix Diff directory dlist filepath
          generic-deriving ghc-prim hashable hashable-time integer-logarithms
-         QuickCheck quickcheck-instances scientific tagged tasty
+         QuickCheck quickcheck-instances scientific strict tagged tasty
          tasty-golden tasty-hunit tasty-quickcheck template-haskell text
          these time time-compat unordered-containers uuid-types vector
        ];
···
      }:
      mkDerivation {
        pname = "aeson-with";
-       version = "0.1.1.1";
-       sha256 = "0dfb7ra2gl24vdi5am23rpz7p5mrjig9pxhrb4i7pbqhjlnhhk2g";
+       version = "0.1.1.2";
+       sha256 = "14sj4zx8g03vb4wdvri41yr3rhilczq4chyy7nl4l2wpk58g246c";
        libraryHaskellDepends = [
          aeson base hashmap lens lens-aeson mtl scientific text
          unordered-containers vector
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "alarmclock_0_7_0_5" = callPackage
+    ({ mkDerivation, async, base, clock, hspec, stm, time
+     , unbounded-delays
+     }:
+     mkDerivation {
+       pname = "alarmclock";
+       version = "0.7.0.5";
+       sha256 = "0197phsc4rn5mn155hbmxplxi2ymra1x6lxq16xs6a8zrk4gfkj9";
+       libraryHaskellDepends = [
+         async base clock stm time unbounded-delays
+       ];
+       testHaskellDepends = [
+         async base clock hspec stm time unbounded-delays
+       ];
+       description = "Wake up and perform an action at a certain time";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "alea" = callPackage
     ({ mkDerivation, base, optparse-applicative, random, text }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "alex-meta";
-       version = "0.3.0.11";
-       sha256 = "0pb6m2h9r3j71iy8ch8kgvssblidlr6r7k12fa1q2v7wi5q2mq91";
+       version = "0.3.0.12";
+       sha256 = "0s0yhkl0ymr50agqnsbscw8926jk4044n6scw086ylhcijx3qmxa";
        libraryHaskellDepends = [
          array base containers haskell-src-meta QuickCheck template-haskell
        ];
···
        ];
        description = "A simple streamly wrapper for amqp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
-     }) {testcontainers = null;};
+     }) {};
 
   "amqp-utils" = callPackage
     ({ mkDerivation, amqp, base, bytestring, connection, containers
···
        broken = true;
      }) {inherit (pkgs) libaosd;};
 
+  "ap-normalize" = callPackage
+    ({ mkDerivation, base, inspection-testing, transformers }:
+     mkDerivation {
+       pname = "ap-normalize";
+       version = "0.1.0.0";
+       sha256 = "0iqfilamnp0k170af7sw0ydn0cmba7ab06yinkl8vfppf583a4la";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base inspection-testing transformers ];
+       description = "Self-normalizing applicative expressions";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "ap-reflect" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
 
   "apply-refact" = callPackage
     ({ mkDerivation, base, containers, directory, extra, filemanip
-     , filepath, ghc, ghc-boot-th, ghc-exactprint, mtl
-     , optparse-applicative, process, refact, silently, syb, tasty
-     , tasty-expected-failure, tasty-golden, transformers, unix-compat
+     , filepath, ghc, ghc-boot-th, ghc-exactprint, optparse-applicative
+     , process, refact, silently, syb, tasty, tasty-expected-failure
+     , tasty-golden, transformers, unix-compat
      }:
      mkDerivation {
        pname = "apply-refact";
-       version = "0.8.2.0";
-       sha256 = "0bhf20b5h095d5a6955hk43k7z4ypkiivq755a21y7nc83l8q5x0";
+       version = "0.8.2.1";
+       sha256 = "12dnwsv37bhla7cnqa3h24mnvdk5199lwd5mf845n1r6xqrh2vvp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers directory extra filemanip ghc ghc-exactprint mtl
+         base containers directory extra filemanip ghc ghc-exactprint
          process refact syb transformers unix-compat
        ];
        executableHaskellDepends = [
          base containers directory extra filemanip filepath ghc ghc-boot-th
-         ghc-exactprint mtl optparse-applicative process refact syb
-         transformers unix-compat
+         ghc-exactprint optparse-applicative process refact syb transformers
+         unix-compat
        ];
        testHaskellDepends = [
          base containers directory extra filemanip filepath ghc ghc-boot-th
-         ghc-exactprint mtl optparse-applicative process refact silently syb
+         ghc-exactprint optparse-applicative process refact silently syb
          tasty tasty-expected-failure tasty-golden transformers unix-compat
        ];
        description = "Perform refactorings specified by the refact library";
···
        pname = "archive-libarchive";
        version = "1.0.0.0";
        sha256 = "0pqq76gnk6y71c5wwjhq99y2695v6bfyzjb8gakp6h3jivcpd2gb";
+       revision = "1";
+       editedCabalFile = "12wq8nisyr2i1861v2377llha63nqpiys9vk6dvg9rfz7f6qqdch";
        libraryHaskellDepends = [
          base bytestring composition-prelude libarchive
        ];
···
      }:
      mkDerivation {
        pname = "atom-conduit";
-       version = "0.8.0.0";
-       sha256 = "0vakq72n9q6hk6ysl64qcyrrya2gp2l3s97n3vggwv84p167xqwd";
+       version = "0.9.0.0";
+       sha256 = "0kjdw3x5jsa5hjb36zq93xyp3ac1s4j5vpb52969hckcghmyrabm";
        libraryHaskellDepends = [
          base-noprelude blaze-builder conduit microlens microlens-th parsers
          prettyprinter refined relude safe-exceptions text time timerep
···
      }:
      mkDerivation {
        pname = "avwx";
-       version = "0.3.0.2";
-       sha256 = "02pvh2i1f96k3pyrmdb3jv2ia7mcp8q5pw067psr8k2sw329qadl";
+       version = "0.3.0.3";
+       sha256 = "1yvyyvfgga5gpf6bw5wkaxzwqvvvlzbqlq217h454gzlsm8vlv52";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ attoparsec base HTTP lens parsers text ];
···
      }:
      mkDerivation {
        pname = "aws-lambda-haskell-runtime";
-       version = "3.0.2";
-       sha256 = "18gdr7jmaq7csh5c27aam5cbyydw9d0bzv9frnck3ggpfqjnb84i";
+       version = "3.0.3";
+       sha256 = "0dxzdc4ixl33njind48g014rfk6wxyg0pdcwiarn4vgb30h6h4kq";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive http-client http-types path
          path-io safe-exceptions-checked template-haskell text
···
      }:
      mkDerivation {
        pname = "aws-lambda-haskell-runtime-wai";
-       version = "1.0.1";
-       sha256 = "0kzk5nnya39k2h0nn321qg16ss1h6yvymy7r77cbrk015572yck9";
+       version = "1.0.2";
+       sha256 = "0bjqrwl2kcnxv8yni2bxaz5x3pgs3j6c4rrgqpv5kfs7yn1ins7w";
        libraryHaskellDepends = [
          aeson aws-lambda-haskell-runtime base binary bytestring
          case-insensitive http-types iproute network text
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "bank-holidays-england_0_2_0_5" = callPackage
+    ({ mkDerivation, base, containers, hspec, QuickCheck, time }:
+     mkDerivation {
+       pname = "bank-holidays-england";
+       version = "0.2.0.5";
+       sha256 = "0n7q9s1vsmh5adkhpgycz8y6q49xqf77fpmm73cw0iqgjly4x9hp";
+       libraryHaskellDepends = [ base containers time ];
+       testHaskellDepends = [ base containers hspec QuickCheck time ];
+       description = "Calculation of bank holidays in England and Wales";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "banwords" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, data-default, HUnit
      , test-framework, test-framework-hunit, text, vector
···
 
   "bitset-word8" = callPackage
     ({ mkDerivation, base, bytestring, containers, criterion, deepseq
-     , hspec, QuickCheck, template-haskell, th-lift-instances, vector
-     }:
-     mkDerivation {
-       pname = "bitset-word8";
-       version = "0.1.1.1";
-       sha256 = "1pjjpqfqjnylfs5npnh7w75h9xk5gpkwzaqx0a972wa9h18gih7z";
-       libraryHaskellDepends = [
-         base containers template-haskell th-lift-instances
-       ];
-       testHaskellDepends = [
-         base containers hspec QuickCheck template-haskell th-lift-instances
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring containers criterion deepseq template-haskell
-         th-lift-instances vector
-       ];
-       description = "Space efficient set of Word8 and some pre-canned sets useful for parsing HTTP";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "bitset-word8_0_1_1_2" = callPackage
-    ({ mkDerivation, base, bytestring, containers, criterion, deepseq
      , hspec, hspec-discover, QuickCheck, template-haskell
      , th-lift-instances, vector
      }:
···
        ];
        description = "Space efficient set of Word8 and some pre-canned sets useful for parsing HTTP";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "bitspeak" = callPackage
···
        broken = true;
      }) {};
 
+  "bludigon" = callPackage
+    ({ mkDerivation, base, containers, data-default, deepseq, directory
+     , filepath, finite-typelits, hspec, libX11, libXrandr, lifted-base
+     , monad-control, mtl, process, QuickCheck, text, time, transformers
+     , transformers-base, unix, X11
+     }:
+     mkDerivation {
+       pname = "bludigon";
+       version = "0.1.0.1";
+       sha256 = "1c0a6a6ir09vxdjv6nx94c73q381c1wbyf4s7p13cah2zh0y4gw4";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers data-default deepseq directory filepath
+         finite-typelits lifted-base monad-control mtl process text time
+         transformers transformers-base unix X11
+       ];
+       librarySystemDepends = [ libX11 libXrandr ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base data-default deepseq hspec mtl QuickCheck time
+       ];
+       description = "Configurable blue light filter";
+       license = stdenv.lib.licenses.bsd3;
+     }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXrandr;};
+
   "bluemix-sdk" = callPackage
     ({ mkDerivation, aeson, base, bytestring, http-client, http-types
      , text, vector
···
 
   "box" = callPackage
     ({ mkDerivation, attoparsec, base, comonad, concurrency
-     , contravariant, dejafu, doctest, exceptions, foldl, generic-lens
-     , lens, mmorph, mtl, numhask, optparse-generic, profunctors, random
-     , streaming, text, time, transformers, transformers-base
-     , websockets
+     , contravariant, dejafu, doctest, exceptions, generic-lens, lens
+     , mmorph, mtl, numhask, optparse-generic, profunctors, random, text
+     , time, transformers, transformers-base, websockets
      }:
      mkDerivation {
        pname = "box";
-       version = "0.5.0";
-       sha256 = "1r3jcnrdjyn894y574fjymrpfrpbwgrfmmvxgbkpa0m1ny8j3nln";
+       version = "0.6.0";
+       sha256 = "0kv3j0fh2ahn4x2lgpghhkrbw5y1cy5mdlrriycqv4slrdzaqyks";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         attoparsec base comonad concurrency contravariant exceptions foldl
-         lens mmorph numhask profunctors streaming text time transformers
-         transformers-base
+         attoparsec base comonad concurrency contravariant exceptions lens
+         mmorph numhask profunctors text time transformers transformers-base
        ];
        executableHaskellDepends = [
          base concurrency dejafu exceptions generic-lens lens mtl numhask
-         optparse-generic random streaming text transformers websockets
+         optparse-generic random text transformers websockets
        ];
        testHaskellDepends = [ base doctest numhask ];
        description = "boxes";
···
      }) {};
 
   "box-csv" = callPackage
-    ({ mkDerivation, attoparsec, base, box, doctest, foldl
-     , generic-lens, lens, numhask, scientific, text, time
+    ({ mkDerivation, attoparsec, base, box, doctest, generic-lens, lens
+     , numhask, scientific, text, time
      }:
      mkDerivation {
        pname = "box-csv";
-       version = "0.0.1";
-       sha256 = "1vyqrc527d4xfv55qw6d0arpsrac3jfzsymh8fqi33s592fnz61d";
+       version = "0.0.2";
+       sha256 = "09qmxd9mxyag6zx8y5yv7bphycbs35zfkkf7kvkdmjqdk7l7b0fd";
        libraryHaskellDepends = [
-         attoparsec base box foldl generic-lens lens numhask scientific text
-         time
+         attoparsec base box generic-lens lens numhask scientific text time
        ];
        testHaskellDepends = [ base doctest numhask ];
        description = "See readme.md";
···
      }:
      mkDerivation {
        pname = "box-socket";
-       version = "0.0.1";
-       sha256 = "1r9ghvhizm468mw3bfwjwrdncggswjvl4hq7pwfxl5c8rp6va74q";
+       version = "0.0.2";
+       sha256 = "0wf7smpzczqm0yqnphmp46bgm67nyhj0swn0vxhdgb8z0362szsp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "bugzilla-redhat" = callPackage
+    ({ mkDerivation, aeson, base, blaze-builder, bytestring, connection
+     , containers, http-conduit, http-types, iso8601-time, resourcet
+     , text, time, transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "bugzilla-redhat";
+       version = "0.3.0";
+       sha256 = "1d751f1219ivx9bfdl7xb89w2vns07ciqp4cqcykixnllx2jx18y";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base blaze-builder bytestring connection containers
+         http-conduit http-types iso8601-time resourcet text time
+         transformers unordered-containers vector
+       ];
+       description = "A Haskell interface to the Bugzilla native REST API";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "build" = callPackage
     ({ mkDerivation, algebraic-graphs, base, containers, extra
      , filepath, mtl, random, transformers
···
      }:
      mkDerivation {
        pname = "burrito";
-       version = "1.1.0.1";
-       sha256 = "197lchafv56g8kcxzfgdgkcygi5f8bddxqzhbsvb8c0gwlv7g270";
+       version = "1.1.0.2";
+       sha256 = "1k625j5syyiq66i88zy6q0mvwkjl5jsj79sxdmd1rbam3m39whx1";
        libraryHaskellDepends = [
          base bytestring containers parsec template-haskell text
          transformers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "bytestring_0_10_10_1" = callPackage
-    ({ mkDerivation, base, byteorder, deepseq, directory, dlist
-     , ghc-prim, HUnit, integer-gmp, mtl, QuickCheck, random
-     , test-framework, test-framework-hunit, test-framework-quickcheck2
-     }:
+  "bytestring_0_10_12_0" = callPackage
+    ({ mkDerivation, base, deepseq, ghc-prim, integer-gmp }:
      mkDerivation {
        pname = "bytestring";
-       version = "0.10.10.1";
-       sha256 = "1imcy8yw5jag91qncvi1s9n0lldmf2pjkja6qq4mfqyh02f7arvq";
+       version = "0.10.12.0";
+       sha256 = "1s1kgnqb8ybz223sf2838mmxnlhwsd3lnakng6ap38m058bzzj7d";
        libraryHaskellDepends = [ base deepseq ghc-prim integer-gmp ];
-       testHaskellDepends = [
-         base byteorder deepseq directory dlist ghc-prim HUnit mtl
-         QuickCheck random test-framework test-framework-hunit
-         test-framework-quickcheck2
-       ];
        description = "Fast, compact, strict and lazy byte strings with a list interface";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "cabal-debian_5_1" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, bifunctors, Cabal
+     , containers, data-default, debian, deepseq, Diff, directory
+     , exceptions, filepath, hsemail, HUnit, lens, mtl, network-uri
+     , newtype-generics, optparse-applicative, parsec, pretty, process
+     , pureMD5, regex-tdfa, syb, text, unix, unliftio, utf8-string
+     }:
+     mkDerivation {
+       pname = "cabal-debian";
+       version = "5.1";
+       sha256 = "14kh2s61m7wm9h0ms4dlpfvqr2gd8fv0w44ar3c3dg5053hwrvny";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-wl-pprint base bifunctors Cabal containers data-default debian
+         deepseq Diff directory exceptions filepath hsemail HUnit lens mtl
+         network-uri newtype-generics optparse-applicative parsec pretty
+         process pureMD5 regex-tdfa syb text unix unliftio utf8-string
+       ];
+       executableHaskellDepends = [ base Cabal debian lens mtl pretty ];
+       description = "Create a Debianization for a Cabal package";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "cabal-dependency-licenses" = callPackage
     ({ mkDerivation, base, Cabal, containers, directory, filepath }:
      mkDerivation {
···
        pname = "cabal-doctest";
        version = "1.0.8";
        sha256 = "03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0";
-       revision = "1";
-       editedCabalFile = "0z0r7h2y5six2zgfylcwr9g4j78qph35zqglk9lz4za1klvgdprl";
+       revision = "2";
+       editedCabalFile = "05v1awad3d1wvc763xcgvxm4n6n7bs7byc6s14kdbw35zcaddlcb";
        libraryHaskellDepends = [ base Cabal directory filepath ];
        description = "A Setup.hs helper for doctests running";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.publicDomain;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
+     }) {};
+
+  "caerbannog" = callPackage
+    ({ mkDerivation, base, binary, bytestring, hspec, QuickCheck
+     , random
+     }:
+     mkDerivation {
+       pname = "caerbannog";
+       version = "0.6.0.3";
+       sha256 = "0mv10cc50365kz2ad36wivvhcyl43bwxjp71f0n9vq2ndrmb4dna";
+       libraryHaskellDepends = [ base binary bytestring ];
+       testHaskellDepends = [
+         base binary bytestring hspec QuickCheck random
+       ];
+       description = "That rabbit's got a vicious streak a mile wide!";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "caf" = callPackage
···
 
   "chart-svg" = callPackage
     ({ mkDerivation, attoparsec, base, Color, containers, doctest
-     , foldl, generic-lens, lens, lucid, numhask, numhask-space
-     , pretty-simple, scientific, tagsoup, text, time, transformers
+     , generic-lens, lens, lucid, numhask, numhask-space, pretty-simple
+     , scientific, tagsoup, text, time, transformers
      , unordered-containers, web-rep
      }:
      mkDerivation {
        pname = "chart-svg";
-       version = "0.1.1";
-       sha256 = "0k3z2950dv5cj5mzxkipfkav44jckv60xj0b9zlli8xnj1gzrx58";
+       version = "0.1.3";
+       sha256 = "0b3hpxm7xjw8pjhpcla46jdsjhqxxb3ga0jmmj97wn6w971yphi1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         attoparsec base Color foldl generic-lens lens lucid numhask
-         numhask-space pretty-simple scientific tagsoup text time
-         transformers web-rep
+         attoparsec base Color generic-lens lens lucid numhask numhask-space
+         pretty-simple scientific tagsoup text time transformers web-rep
        ];
        executableHaskellDepends = [
          base containers generic-lens lens lucid numhask numhask-space text
···
        ];
        testHaskellDepends = [ base doctest numhask ];
        description = "Charts in SVG";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "chart-svg-various" = callPackage
+    ({ mkDerivation, base, box, box-csv, box-socket, chart-svg
+     , concurrency, doctest, foldl, lens, lucid, mealy, numhask
+     , numhask-array, numhask-space, text, time, transformers
+     , unordered-containers, web-rep
+     }:
+     mkDerivation {
+       pname = "chart-svg-various";
+       version = "0.0.1";
+       sha256 = "0ajmm6xhzxay715c4zds6lcjnhp8l9qf78rzhymd4hc6vz9v0pi1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base box box-csv box-socket chart-svg concurrency foldl lens lucid
+         mealy numhask numhask-array numhask-space text time transformers
+         unordered-containers web-rep
+       ];
+       executableHaskellDepends = [ base numhask ];
+       testHaskellDepends = [ base doctest numhask ];
+       description = "See readme.md";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
···
      }:
      mkDerivation {
        pname = "clash-ghc";
-       version = "1.2.3";
-       sha256 = "1ifd8skqbgqcsclm5sxaikc25gwv5da5dv64kjy23r45sxlv11by";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         array base bifunctors bytestring Cabal clash-lib clash-prelude
-         concurrent-supply containers deepseq directory filepath ghc
-         ghc-boot ghc-prim ghc-typelits-extra ghc-typelits-knownnat
-         ghc-typelits-natnormalise ghci hashable haskeline integer-gmp lens
-         mtl primitive process reflection split template-haskell text time
-         transformers uniplate unix unordered-containers utf8-string vector
-       ];
-       executableHaskellDepends = [ base ];
-       description = "CAES Language for Synchronous Hardware";
-       license = stdenv.lib.licenses.bsd2;
-     }) {};
-
-  "clash-ghc_1_2_4" = callPackage
-    ({ mkDerivation, array, base, bifunctors, bytestring, Cabal
-     , clash-lib, clash-prelude, concurrent-supply, containers, deepseq
-     , directory, filepath, ghc, ghc-boot, ghc-prim, ghc-typelits-extra
-     , ghc-typelits-knownnat, ghc-typelits-natnormalise, ghci, hashable
-     , haskeline, integer-gmp, lens, mtl, primitive, process, reflection
-     , split, template-haskell, text, time, transformers, uniplate, unix
-     , unordered-containers, utf8-string, vector
-     }:
-     mkDerivation {
-       pname = "clash-ghc";
        version = "1.2.4";
        sha256 = "1xzpz0bkdfvhkk496q4zr7f6ix23dgg6w5r14j5gxy4jb8f8bxln";
        isLibrary = true;
···
        executableHaskellDepends = [ base ];
        description = "CAES Language for Synchronous Hardware";
        license = stdenv.lib.licenses.bsd2;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "clash-lib" = callPackage
···
      , ordered-containers, parsers, prettyprinter, primitive, process
      , reducers, tasty, tasty-hunit, template-haskell, temporary
      , terminal-size, text, text-show, time, transformers, trifecta
-     , unordered-containers, vector, vector-binary-instances
-     }:
-     mkDerivation {
-       pname = "clash-lib";
-       version = "1.2.3";
-       sha256 = "0cxhw8wgzvpmg7kfyjf9ys38n98vynndr1fn1pzyc03s4mn2rszm";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         aeson ansi-terminal attoparsec base binary bytestring clash-prelude
-         concurrent-supply containers data-binary-ieee754 data-default
-         deepseq directory dlist errors exceptions extra filepath ghc
-         ghc-boot-th hashable haskell-src-meta hint integer-gmp interpolate
-         lens mtl ordered-containers parsers prettyprinter primitive process
-         reducers template-haskell temporary terminal-size text text-show
-         time transformers trifecta unordered-containers vector
-         vector-binary-instances
-       ];
-       testHaskellDepends = [
-         base clash-prelude concurrent-supply containers data-default
-         deepseq ghc ghc-typelits-knownnat haskell-src-exts lens tasty
-         tasty-hunit template-haskell text transformers unordered-containers
-       ];
-       description = "CAES Language for Synchronous Hardware - As a Library";
-       license = stdenv.lib.licenses.bsd2;
-     }) {};
-
-  "clash-lib_1_2_4" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, attoparsec, base, binary
-     , bytestring, clash-prelude, concurrent-supply, containers
-     , data-binary-ieee754, data-default, deepseq, directory, dlist
-     , errors, exceptions, extra, filepath, ghc, ghc-boot-th
-     , ghc-typelits-knownnat, hashable, haskell-src-exts
-     , haskell-src-meta, hint, integer-gmp, interpolate, lens, mtl
-     , ordered-containers, parsers, prettyprinter, primitive, process
-     , reducers, tasty, tasty-hunit, template-haskell, temporary
-     , terminal-size, text, text-show, time, transformers, trifecta
      , unordered-containers, utf8-string, vector
      , vector-binary-instances
      }:
···
        ];
        description = "CAES Language for Synchronous Hardware - As a Library";
        license = stdenv.lib.licenses.bsd2;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "clash-multisignal" = callPackage
···
      }:
      mkDerivation {
        pname = "clash-prelude";
-       version = "1.2.3";
-       sha256 = "0k3xariqr314c9s53jcf1w6azivcdrq0lnnsbj889453ys0sw9jg";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         array base bifunctors binary bytestring constraints containers
-         data-binary-ieee754 data-default-class deepseq ghc-prim
-         ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise
-         half hashable integer-gmp interpolate lens QuickCheck
-         recursion-schemes reflection singletons template-haskell text
-         text-show th-abstraction th-lift th-orphans time transformers
-         type-errors uniplate vector
-       ];
-       testHaskellDepends = [
-         base doctest ghc-typelits-knownnat hint quickcheck-classes-base
-         tasty tasty-hunit tasty-quickcheck template-haskell
-       ];
-       benchmarkHaskellDepends = [
-         base criterion deepseq template-haskell
-       ];
-       description = "CAES Language for Synchronous Hardware - Prelude library";
-       license = stdenv.lib.licenses.bsd2;
-     }) {};
-
-  "clash-prelude_1_2_4" = callPackage
-    ({ mkDerivation, array, base, bifunctors, binary, bytestring, Cabal
-     , cabal-doctest, constraints, containers, criterion
-     , data-binary-ieee754, data-default-class, deepseq, doctest
-     , ghc-prim, ghc-typelits-extra, ghc-typelits-knownnat
-     , ghc-typelits-natnormalise, half, hashable, hint, integer-gmp
-     , interpolate, lens, QuickCheck, quickcheck-classes-base
-     , recursion-schemes, reflection, singletons, tasty, tasty-hunit
-     , tasty-quickcheck, template-haskell, text, text-show
-     , th-abstraction, th-lift, th-orphans, time, transformers
-     , type-errors, uniplate, vector
-     }:
-     mkDerivation {
-       pname = "clash-prelude";
        version = "1.2.4";
        sha256 = "1yizprs6i4y2vyhjj6pvpd5xmdbxyqjwclk6saaws0g3xv008ffg";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        ];
        description = "CAES Language for Synchronous Hardware - Prelude library";
        license = stdenv.lib.licenses.bsd2;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "clash-prelude-quickcheck" = callPackage
···
      }:
      mkDerivation {
        pname = "commonmark";
-       version = "0.1.0.1";
-       sha256 = "1p5z52n795ncrx94q9v1kyw3y1fqdi6vdz5iyg6n9pis7raqiy0i";
+       version = "0.1.0.2";
+       sha256 = "00rqy02pn4gg0wpwvxyqxvzqg75lvb1qawn4m8rnjq6v43c4g23l";
        libraryHaskellDepends = [
          base bytestring containers parsec text transformers
        ];
···
      }:
      mkDerivation {
        pname = "core-data";
-       version = "0.2.1.5";
-       sha256 = "17lvpbyrr9wm93qprk45n5gf3f6k47f9wf7ays0bfk0hx23chc1n";
+       version = "0.2.1.7";
+       sha256 = "19fcbp6ccwggpv1lm1z03m3innk9agiwbz03whiivr3zg2gzcglh";
        libraryHaskellDepends = [
          aeson base bytestring containers core-text hashable prettyprinter
          prettyprinter-ansi-terminal scientific text unordered-containers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "core-data_0_2_1_7" = callPackage
+  "core-data_0_2_1_8" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, core-text
      , hashable, prettyprinter, prettyprinter-ansi-terminal, scientific
      , text, unordered-containers, vector
      }:
      mkDerivation {
        pname = "core-data";
-       version = "0.2.1.7";
-       sha256 = "19fcbp6ccwggpv1lm1z03m3innk9agiwbz03whiivr3zg2gzcglh";
+       version = "0.2.1.8";
+       sha256 = "1hgvvkk3m3ykdndmf2hbm59v0pim68jwgl2a6n5hw1dv4xwd3fay";
        libraryHaskellDepends = [
          aeson base bytestring containers core-text hashable prettyprinter
          prettyprinter-ansi-terminal scientific text unordered-containers
···
      }:
      mkDerivation {
        pname = "core-program";
-       version = "0.2.4.2";
-       sha256 = "0zs62mn87fdrjwi1dp11hkr7nbb7v3ikxk1ph6cnjdk0di9hrr6a";
+       version = "0.2.4.4";
+       sha256 = "1mkhwfw4h5q2dly1gm082k3s9jsq2wb0xksfa6xv8ghvxpvypvck";
        libraryHaskellDepends = [
          async base bytestring chronologique core-data core-text directory
          exceptions filepath fsnotify hashable hourglass mtl prettyprinter
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "core-program_0_2_4_4" = callPackage
+  "core-program_0_2_4_5" = callPackage
     ({ mkDerivation, async, base, bytestring, chronologique, core-data
      , core-text, directory, exceptions, filepath, fsnotify, hashable
      , hourglass, mtl, prettyprinter, prettyprinter-ansi-terminal
···
      }:
      mkDerivation {
        pname = "core-program";
-       version = "0.2.4.4";
-       sha256 = "1mkhwfw4h5q2dly1gm082k3s9jsq2wb0xksfa6xv8ghvxpvypvck";
+       version = "0.2.4.5";
+       sha256 = "1a2zjdywmgniwcj649f43hri55bh30vz2s00r3yqj3gvhhighi86";
        libraryHaskellDepends = [
          async base bytestring chronologique core-data core-text directory
          exceptions filepath fsnotify hashable hourglass mtl prettyprinter
···
      }:
      mkDerivation {
        pname = "core-text";
-       version = "0.2.3.3";
-       sha256 = "0bnbl34fzy497a8ljgcydp490j3684yw8r32jijqyix7y9q2cl2d";
+       version = "0.2.3.5";
+       sha256 = "085w21vh5rgl1pc7731ih47gh8gszjj0xfgkr3acy0r9rbh33m9c";
        libraryHaskellDepends = [
          base bytestring deepseq fingertree hashable prettyprinter
          prettyprinter-ansi-terminal template-haskell text text-short
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "core-text_0_2_3_5" = callPackage
+  "core-text_0_2_3_6" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, fingertree, hashable
      , prettyprinter, prettyprinter-ansi-terminal, template-haskell
      , text, text-short
      }:
      mkDerivation {
        pname = "core-text";
-       version = "0.2.3.5";
-       sha256 = "085w21vh5rgl1pc7731ih47gh8gszjj0xfgkr3acy0r9rbh33m9c";
+       version = "0.2.3.6";
+       sha256 = "13sdgym8xhljpc465bq1h066mrcvk77568viklhib255skjl56gn";
        libraryHaskellDepends = [
          base bytestring deepseq fingertree hashable prettyprinter
          prettyprinter-ansi-terminal template-haskell text text-short
···
      }:
      mkDerivation {
        pname = "csound-expression";
-       version = "5.3.2";
-       sha256 = "1v3ssy2rfgwz9wwv8kmaifyrphyl5w66p9zmrg1bi0vbzwxnr57q";
+       version = "5.3.3";
+       sha256 = "0g6djh3ijvka6hkw4nhb7vhhyl4i268rdxvnwmm6ayg6a8kg8p0g";
        libraryHaskellDepends = [
          base Boolean colour containers csound-expression-dynamic
          csound-expression-opcodes csound-expression-typed data-default
···
 
   "csound-expression-dynamic" = callPackage
     ({ mkDerivation, array, base, Boolean, containers, data-default
-     , data-fix, data-fix-cse, hashable, transformers, wl-pprint
+     , data-fix, data-fix-cse, deriving-compat, hashable, transformers
+     , wl-pprint
      }:
      mkDerivation {
        pname = "csound-expression-dynamic";
-       version = "0.3.3";
-       sha256 = "0k4pk96cx2f6rhz18mrdkkz7ic2fdzpqkxf1x596990az7pjg7g3";
+       version = "0.3.5";
+       sha256 = "07xykqpym48bvvs7sa0m12psahsn7z245cd89akv9flkgwjwaa29";
        libraryHaskellDepends = [
          array base Boolean containers data-default data-fix data-fix-cse
-         hashable transformers wl-pprint
+         deriving-compat hashable transformers wl-pprint
        ];
        description = "dynamic core for csound-expression library";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "csound-expression-typed";
-       version = "0.2.2.0";
-       sha256 = "19cplqpyd7vhn28z0k8mxmscja05w9xb8q4bbvq5qd0h8liqxsqg";
+       version = "0.2.3.1";
+       sha256 = "02zd41sz1y8qfchdyhgiddi6s1p5081nr5haq04qdmbz5bgpdmbq";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base Boolean colour containers csound-expression-dynamic
···
      }:
      mkDerivation {
        pname = "cuckoo";
-       version = "0.2.0.1";
-       sha256 = "1q070hzrsm0f1lfxnsk4jmmb9pay98522k2lqncvzg09fm2a687j";
+       version = "0.2.1";
+       sha256 = "1bv39vfg0yzancyya1cdbrcdc0gasp0djcc9ryiwrc3kf9y0nbzn";
        libraryHaskellDepends = [ base memory primitive random vector ];
        testHaskellDepends = [
-         base bytestring cryptonite doctest hashable memory stopwatch
+         base bytestring cryptonite doctest hashable memory primitive
+         stopwatch
        ];
        benchmarkHaskellDepends = [
          base bytestring criterion memory QuickCheck stopwatch
···
 
   "cut-the-crap" = callPackage
     ({ mkDerivation, base, exceptions, generic-lens, hspec, hspec-core
-     , lens, optparse-applicative, regex-tdfa, shelly, system-filepath
-     , temporary, text, unliftio-core
+     , lens, optparse-applicative, pocketsphinx, QuickCheck
+     , quickcheck-classes, regex-tdfa, shelly, sphinxbase
+     , system-filepath, temporary, text, time, unliftio-core
      }:
      mkDerivation {
        pname = "cut-the-crap";
-       version = "1.3.0";
-       sha256 = "1pvqz44panx6xp0zw2wip0hz66gsjz569d0n6gayr4sj8scskasp";
+       version = "1.4.0";
+       sha256 = "03xip8a9inqir8zm244ffv92ag5r7z8hlh0qz7z4vfdmg54mhhnq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base exceptions generic-lens lens optparse-applicative regex-tdfa
-         shelly system-filepath temporary text unliftio-core
+         shelly system-filepath temporary text time unliftio-core
        ];
+       libraryPkgconfigDepends = [ pocketsphinx sphinxbase ];
        executableHaskellDepends = [
          base exceptions generic-lens lens optparse-applicative regex-tdfa
-         shelly system-filepath temporary text unliftio-core
+         shelly system-filepath temporary text time unliftio-core
        ];
+       executablePkgconfigDepends = [ pocketsphinx sphinxbase ];
        testHaskellDepends = [
          base exceptions generic-lens hspec hspec-core lens
-         optparse-applicative regex-tdfa shelly system-filepath temporary
-         text unliftio-core
+         optparse-applicative QuickCheck quickcheck-classes regex-tdfa
+         shelly system-filepath temporary text time unliftio-core
        ];
+       testPkgconfigDepends = [ pocketsphinx sphinxbase ];
        description = "Cuts out uninteresting parts of videos by detecting silences";
        license = stdenv.lib.licenses.mit;
-     }) {};
+     }) {inherit (pkgs) pocketsphinx; inherit (pkgs) sphinxbase;};
 
   "cutter" = callPackage
     ({ mkDerivation, base, bytestring, explicit-exception, spreadsheet
···
     ({ mkDerivation, base, containers, data-fix, transformers }:
      mkDerivation {
        pname = "data-fix-cse";
-       version = "0.0.2";
-       sha256 = "1xn6qnir5dss23y8d71dsy78sdk7hczwprxir8v6la15c43rf9p2";
+       version = "0.0.3";
+       sha256 = "1v8ffi5c0sz8q2fla6fab4css3pkjmi0knx5d04mvffhw66bjhbz";
        libraryHaskellDepends = [ base containers data-fix transformers ];
        description = "Common subexpression elimination for the fixploint types";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall_1_33_1" = callPackage
+  "dhall_1_34_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, atomic-write
      , base, bytestring, case-insensitive, cborg, cborg-json, containers
      , contravariant, cryptonite, data-fix, deepseq, Diff, directory
      , doctest, dotgen, either, exceptions, filepath, foldl, gauge
      , generic-random, half, hashable, haskeline, http-client
      , http-client-tls, http-types, lens-family-core, megaparsec, memory
-     , mockery, mtl, network-uri, optparse-applicative
+     , mmorph, mockery, mtl, network-uri, optparse-applicative
      , parser-combinators, parsers, pretty-simple, prettyprinter
      , prettyprinter-ansi-terminal, profunctors, QuickCheck
      , quickcheck-instances, repline, scientific, semigroups, serialise
···
      }:
      mkDerivation {
        pname = "dhall";
-       version = "1.33.1";
-       sha256 = "17l6qh5zhy0gnxw0x5v4c6n00dmgk279lfyi65n2hsbpaspw7h2k";
-       revision = "2";
-       editedCabalFile = "0hxk6ay7kqfi8kwni8hdca4q8qm30xdhfwdgxbl360s3ngps7jg0";
+       version = "1.34.0";
+       sha256 = "0rqvzvcqbhs9gvga7api6jjblnypm4a33z8kxi578ps63mhn3g0d";
        isLibrary = true;
        isExecutable = true;
+       enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson aeson-pretty ansi-terminal atomic-write base bytestring
          case-insensitive cborg cborg-json containers contravariant
          cryptonite data-fix deepseq Diff directory dotgen either exceptions
          filepath half hashable haskeline http-client http-client-tls
-         http-types lens-family-core megaparsec memory mtl network-uri
-         optparse-applicative parser-combinators parsers pretty-simple
-         prettyprinter prettyprinter-ansi-terminal profunctors repline
-         scientific serialise template-haskell text text-manipulate
+         http-types lens-family-core megaparsec memory mmorph mtl
+         network-uri optparse-applicative parser-combinators parsers
+         pretty-simple prettyprinter prettyprinter-ansi-terminal profunctors
+         repline scientific serialise template-haskell text text-manipulate
          th-lift-instances transformers transformers-compat
          unordered-containers uri-encode vector
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall-bash_1_0_31" = callPackage
+  "dhall-bash_1_0_32" = callPackage
     ({ mkDerivation, base, bytestring, containers, dhall
      , neat-interpolation, optparse-generic, shell-escape, text
      }:
      mkDerivation {
        pname = "dhall-bash";
-       version = "1.0.31";
-       sha256 = "10xp159bzbwnzapixrndg7sb0v5bg7li1nkr48akh6h4icpvnfsp";
+       version = "1.0.32";
+       sha256 = "0y4pjrknbq48j1cnj25zf31k02j5ivjm3h6ffizr3vgr24whfxih";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "dhall-docs" = callPackage
     ({ mkDerivation, base, bytestring, containers, dhall, directory
-     , doctest, file-embed, filepath, HaXml, lucid, megaparsec, mmark
-     , mtl, optparse-applicative, path, path-io, pretty, prettyprinter
-     , tar, tasty, tasty-silver, text
+     , doctest, file-embed, filepath, foldl, HaXml, lens-family-core
+     , lucid, megaparsec, mmark, mtl, optparse-applicative, path
+     , path-io, pretty, prettyprinter, tar, tasty, tasty-hunit
+     , tasty-silver, text, turtle
      }:
      mkDerivation {
        pname = "dhall-docs";
-       version = "0.0.1";
-       sha256 = "1cb3xlb27bw8csvg7a73whr4ld608g1w9i5nc7z799ry3pp64m0n";
+       version = "1.0.0";
+       sha256 = "0kfn3nr0g4x5bpdrkg5lh8qma2536k3gx7bvrsrkn53lyyxnbnvi";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bytestring containers dhall directory file-embed filepath
-         lucid megaparsec mmark mtl optparse-applicative path path-io
-         prettyprinter tar text
+         lens-family-core lucid megaparsec mmark mtl optparse-applicative
+         path path-io prettyprinter tar text
        ];
        executableHaskellDepends = [ base dhall ];
        testHaskellDepends = [
-         base containers directory doctest filepath HaXml path path-io
-         pretty tasty tasty-silver text
+         base bytestring containers dhall directory doctest filepath foldl
+         HaXml path path-io pretty tasty tasty-hunit tasty-silver text
+         turtle
        ];
        description = "Generate HTML docs from a dhall package";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall-json_1_7_0" = callPackage
+  "dhall-json_1_7_1" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, aeson-yaml, ansi-terminal
      , base, bytestring, containers, dhall, exceptions, filepath
-     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
-     , scientific, tasty, tasty-hunit, tasty-silver, text
-     , unordered-containers, vector
+     , lens-family-core, optparse-applicative, prettyprinter
+     , prettyprinter-ansi-terminal, scientific, tasty, tasty-hunit
+     , tasty-silver, text, unordered-containers, vector
      }:
      mkDerivation {
        pname = "dhall-json";
-       version = "1.7.0";
-       sha256 = "1nk2dibdnzm5wmvlsf82n8hc0zab1chqw339pp9q5n2gavj8kvsi";
-       revision = "1";
-       editedCabalFile = "1xbr4cphc98frf458vsggx5lh3my7ahlz5fl19hnyy876iwb04hm";
+       version = "1.7.1";
+       sha256 = "158c9vhxa124r1xqn365wvwqhby5rngkip08ghy8rnjs5ijcxzgf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty aeson-yaml base bytestring containers dhall
-         exceptions filepath optparse-applicative prettyprinter scientific
-         text unordered-containers vector
+         exceptions filepath lens-family-core optparse-applicative
+         prettyprinter scientific text unordered-containers vector
        ];
        executableHaskellDepends = [
          aeson aeson-pretty ansi-terminal base bytestring dhall exceptions
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "dhall-lsp-server_1_0_9" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
+     , data-default, dhall, dhall-json, directory, doctest, filepath
+     , haskell-lsp, haskell-lsp-types, hslogger, lens, lens-family-core
+     , lsp-test, megaparsec, mtl, network-uri, optparse-applicative
+     , prettyprinter, QuickCheck, rope-utf16-splay, tasty, tasty-hspec
+     , text, transformers, unordered-containers, uri-encode
+     }:
+     mkDerivation {
+       pname = "dhall-lsp-server";
+       version = "1.0.9";
+       sha256 = "0zf53pc8rxapmdm9fvp04gfnw2910yv1gm5sm5v5wb606njzk0xn";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring containers data-default dhall
+         dhall-json directory filepath haskell-lsp hslogger lens
+         lens-family-core megaparsec mtl network-uri prettyprinter
+         rope-utf16-splay text transformers unordered-containers uri-encode
+       ];
+       executableHaskellDepends = [ base optparse-applicative ];
+       testHaskellDepends = [
+         base directory doctest filepath haskell-lsp-types lsp-test
+         QuickCheck tasty tasty-hspec text
+       ];
+       description = "Language Server Protocol (LSP) server for Dhall";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "dhall-nix" = callPackage
     ({ mkDerivation, base, containers, data-fix, dhall, hnix
      , lens-family-core, neat-interpolation, optparse-generic, text
      }:
      mkDerivation {
        pname = "dhall-nix";
-       version = "1.1.15";
-       sha256 = "0ynbl5nrsql9y0nh7kiyvf9h0z61d2d5v1iga8vidaqvdkih383h";
-       revision = "1";
-       editedCabalFile = "0fkc59w12pdd7wzf11x8glkvvq1jj482dmzzq1d2h1xd8z616zkz";
+       version = "1.1.16";
+       sha256 = "1p9aizzf7zx92ns292zyzvg01r85dpl3wa61nh6g3q16qjs35bcx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
+     }) {};
+
+  "dhall-nixpkgs" = callPackage
+    ({ mkDerivation, aeson, base, data-fix, dhall, foldl, hnix
+     , lens-family-core, megaparsec, mmorph, neat-interpolation
+     , network-uri, optparse-applicative, prettyprinter, text
+     , transformers, turtle
+     }:
+     mkDerivation {
+       pname = "dhall-nixpkgs";
+       version = "1.0.0";
+       sha256 = "1bymafh0p0avfsdpcijj76075pgkn81sf6f3y17m7p0lmp8hhh75";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson base data-fix dhall foldl hnix lens-family-core megaparsec
+         mmorph neat-interpolation network-uri optparse-applicative
+         prettyprinter text transformers turtle
+       ];
+       description = "Convert Dhall projects to Nix packages";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "dhall-text" = callPackage
···
        broken = true;
      }) {};
 
-  "dhall-yaml_1_2_0" = callPackage
+  "dhall-yaml_1_2_1" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, dhall
      , dhall-json, exceptions, HsYAML, HsYAML-aeson
      , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
···
      }:
      mkDerivation {
        pname = "dhall-yaml";
-       version = "1.2.0";
-       sha256 = "0jvz8xjj2f0g8pxaspgvg7rzhfyccz1rgvp4l3c9zjri3wirxpwp";
-       revision = "1";
-       editedCabalFile = "0qkwnckzr04442iz6x0cba7m8nclw18pb4icnpxrxnn9fxc7blx5";
+       version = "1.2.1";
+       sha256 = "18p8a92wiz2zi4q7v5fjvdallxrl21scmwwv706g3mm5dgfgcs5a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
   "discord-haskell" = callPackage
     ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring
      , containers, data-default, emoji, http-client, iso8601-time
-     , JuicyPixels, MonadRandom, req, safe-exceptions, text, time
-     , unordered-containers, vector, websockets, wuss
+     , JuicyPixels, MonadRandom, mtl, req, safe-exceptions, text, time
+     , unliftio, unordered-containers, vector, websockets, wuss
      }:
      mkDerivation {
        pname = "discord-haskell";
-       version = "1.6.1";
-       sha256 = "0id3y2zg1hg0mj6ymjm4khmsdnjdl3i7sm9b7jvw5vy44956cf5y";
+       version = "1.7.0";
+       sha256 = "1hb2qfljj0xq427657ml8qasg99fhwh0zfsrmryqpaq5ch8aqn20";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson async base base64-bytestring bytestring containers
          data-default emoji http-client iso8601-time JuicyPixels MonadRandom
-         req safe-exceptions text time unordered-containers vector
-         websockets wuss
+         mtl req safe-exceptions text time unliftio unordered-containers
+         vector websockets wuss
        ];
-       executableHaskellDepends = [ base text ];
+       executableHaskellDepends = [ base text unliftio ];
        description = "Write bots for Discord in Haskell";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
···
     ({ mkDerivation, base, mmsyn3, mmsyn6ukr, mmsyn7s, vector }:
      mkDerivation {
        pname = "dobutokO-poetry";
-       version = "0.7.0.0";
-       sha256 = "0c2838dn34hwh9z0j1qhz276zf7zypr0gq25ym4m6wzpni14scj7";
+       version = "0.9.0.1";
+       sha256 = "1wjxmlcz5xyc3avfm9f74f3scjjqa3a8hn0pav2l0lhkf8r6p5i6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mmsyn3 mmsyn6ukr mmsyn7s vector ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "egison-pattern-src_0_2_1_1" = callPackage
+    ({ mkDerivation, base, containers, free, megaparsec, mtl
+     , parser-combinators, prettyprinter, recursion-schemes, tasty
+     , tasty-discover, tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "egison-pattern-src";
+       version = "0.2.1.1";
+       sha256 = "0zpaxkskpdhq5nm1h6fh1klww4cslz96a3w4fhlaz0v0wdbkbrfs";
+       libraryHaskellDepends = [
+         base containers free megaparsec mtl parser-combinators
+         prettyprinter recursion-schemes text
+       ];
+       testHaskellDepends = [
+         base megaparsec mtl tasty tasty-hunit text
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Manipulating Egison patterns: abstract syntax, parser, and pretty-printer";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "egison-pattern-src-haskell-mode" = callPackage
     ({ mkDerivation, base, egison-pattern-src, haskell-src-exts, mtl
      , tasty, tasty-discover, tasty-hunit, text
      }:
      mkDerivation {
        pname = "egison-pattern-src-haskell-mode";
-       version = "0.2.1.0";
-       sha256 = "0lgvvw23ii0g62b8q67h4mfm2bd07akl2m8dp8855hm16q1b8w8n";
+       version = "0.2.1.1";
+       sha256 = "0k21fi28imqnn2rp5182mjxnrahssbdxay3pzhzj5yyfjp8qymwp";
        libraryHaskellDepends = [
          base egison-pattern-src haskell-src-exts mtl text
        ];
···
        testToolDepends = [ tasty-discover ];
        description = "Parser and pretty printer for Egison pattern expressions to use with TH";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "egison-pattern-src-th-mode_0_2_1_1" = callPackage
+    ({ mkDerivation, base, egison-pattern-src, haskell-src-exts
+     , haskell-src-meta, mtl, pretty, tasty, tasty-discover, tasty-hunit
+     , template-haskell, text
+     }:
+     mkDerivation {
+       pname = "egison-pattern-src-th-mode";
+       version = "0.2.1.1";
+       sha256 = "110rykbxkpv9vrqvwdxm0fa73djy2g5swcxzpx61zh6cl4wk949g";
+       libraryHaskellDepends = [
+         base egison-pattern-src haskell-src-exts haskell-src-meta mtl
+         pretty template-haskell text
+       ];
+       testHaskellDepends = [
+         base egison-pattern-src haskell-src-exts mtl tasty tasty-hunit
+         template-haskell text
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Parser and pretty printer for Egison pattern expressions to use with TH";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "egison-quote" = callPackage
···
 
   "either-result" = callPackage
     ({ mkDerivation, base, doctest, doctest-discover, hspec
-     , hspec-discover
+     , hspec-discover, mtl, transformers
      }:
      mkDerivation {
        pname = "either-result";
-       version = "0.1.2.0";
-       sha256 = "1ch6m0bimbkq73xchhfczssl6pzszkrhcgbcccbzi752r4vps31s";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ base doctest hspec ];
+       version = "0.3.0.0";
+       sha256 = "1cj6g6b90cpfzfsrkja35bs6qfnqnx9fqxwfrkm5985pp0ii546d";
+       libraryHaskellDepends = [ base mtl transformers ];
+       testHaskellDepends = [ base doctest hspec transformers ];
        testToolDepends = [ doctest-discover hspec-discover ];
-       description = "‘Result a’ is a wrapper of ‘Either String a’";
+       description = "‘MonadFail’ instance for a wrapper of ‘ExceptT String m a’";
        license = stdenv.lib.licenses.asl20;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "elynx";
-       version = "0.3.0";
-       sha256 = "15qnsbbfmyyxmhzs5ly84w4yficcmnl3v49wjqhr86836l770rbi";
+       version = "0.3.1";
+       sha256 = "00fm1aixj31djlrmkzvhsk119w00jch6l1alaxmy97gjcg8kk6hd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }) {};
 
   "elynx-markov" = callPackage
-    ({ mkDerivation, base, bytestring, containers, elynx-seq
-     , elynx-tools, elynx-tree, hmatrix, hspec, hspec-megaparsec
-     , integration, math-functions, megaparsec, mwc-random, parallel
-     , primitive, statistics, vector
+    ({ mkDerivation, async, attoparsec, base, bytestring, containers
+     , elynx-seq, elynx-tools, hmatrix, hspec, integration
+     , math-functions, mwc-random, parallel, primitive, statistics
+     , vector
      }:
      mkDerivation {
        pname = "elynx-markov";
-       version = "0.3.0";
-       sha256 = "0w889wjyj4g8yr4ysvh2v1jnsf6bpdri8pj9klslnrpmk4b7x14n";
+       version = "0.3.1";
+       sha256 = "05wjnlz5x6j74m9dc524yagwhj8w3vmxp3x55hkbfq89j44fb6n1";
        libraryHaskellDepends = [
-         base bytestring containers elynx-seq elynx-tools elynx-tree hmatrix
-         integration math-functions megaparsec mwc-random parallel primitive
-         statistics vector
+         async attoparsec base bytestring containers elynx-seq hmatrix
+         integration math-functions mwc-random parallel primitive statistics
+         vector
        ];
        testHaskellDepends = [
-         base containers elynx-tools elynx-tree hmatrix hspec
-         hspec-megaparsec mwc-random vector
+         base containers elynx-tools hmatrix hspec mwc-random vector
        ];
        description = "Simulate molecular sequences along trees";
        license = stdenv.lib.licenses.gpl3Plus;
···
      }) {};
 
   "elynx-nexus" = callPackage
-    ({ mkDerivation, base, bytestring, hspec, megaparsec }:
+    ({ mkDerivation, attoparsec, base, bytestring, hspec }:
      mkDerivation {
        pname = "elynx-nexus";
-       version = "0.3.0";
-       sha256 = "00aikdx89b0x9zw78srp5qmx564myn9dhwy1k6nq9b411cxsfz0v";
-       libraryHaskellDepends = [ base bytestring megaparsec ];
+       version = "0.3.1";
+       sha256 = "0rqhzwfr8zz7nzvc7kkp6n2jxvq4qn3pv9ipk7mfdpxsfcm46550";
+       libraryHaskellDepends = [ attoparsec base bytestring ];
        testHaskellDepends = [ base hspec ];
        description = "Import and export Nexus files";
        license = stdenv.lib.licenses.gpl3Plus;
···
      }) {};
 
   "elynx-seq" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, elynx-tools
-     , hspec, hspec-megaparsec, matrices, megaparsec, mwc-random
-     , parallel, primitive, vector, vector-th-unbox, word8
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
+     , elynx-tools, hspec, matrices, mwc-random, parallel, primitive
+     , vector, vector-th-unbox, word8
      }:
      mkDerivation {
        pname = "elynx-seq";
-       version = "0.3.0";
-       sha256 = "0y7raavskrxgqmfsszm3f177hsjwnf69302vq3k7anj4fzqydvcn";
+       version = "0.3.1";
+       sha256 = "0wvp13kcx0fbhhk45ahs18p24dqn4n7wg1194hfj4v3qxg7pqy7q";
        libraryHaskellDepends = [
-         aeson base bytestring containers elynx-tools matrices megaparsec
-         mwc-random parallel primitive vector vector-th-unbox word8
+         aeson attoparsec base bytestring containers matrices mwc-random
+         parallel primitive vector vector-th-unbox word8
        ];
        testHaskellDepends = [
-         base bytestring elynx-tools hspec hspec-megaparsec matrices vector
+         base bytestring elynx-tools hspec matrices vector
        ];
        description = "Handle molecular sequences";
        license = stdenv.lib.licenses.gpl3Plus;
···
      }) {};
 
   "elynx-tools" = callPackage
-    ({ mkDerivation, aeson, async, base, base16-bytestring, bytestring
-     , containers, cryptohash-sha256, deepseq, directory, fast-logger
-     , hmatrix, matrices, megaparsec, monad-control, monad-logger
-     , mwc-random, optparse-applicative, parallel, primitive
-     , template-haskell, text, time, transformers, transformers-base
-     , vector, zlib
+    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
+     , bytestring, cryptohash-sha256, deepseq, directory, fast-logger
+     , hmatrix, monad-control, monad-logger, mwc-random
+     , optparse-applicative, primitive, template-haskell, text, time
+     , transformers, transformers-base, vector, zlib
      }:
      mkDerivation {
        pname = "elynx-tools";
-       version = "0.3.0";
-       sha256 = "1ba9vcmzf7kwm8h493m2n9naq1pzhsddd8mv3mp8vb30jgg75vhj";
+       version = "0.3.1";
+       sha256 = "1h7vg6dh45mc5snk4c9q0xplb3q68gklxhj295pa20d83jarki0x";
        libraryHaskellDepends = [
-         aeson async base base16-bytestring bytestring containers
-         cryptohash-sha256 deepseq directory fast-logger hmatrix matrices
-         megaparsec monad-control monad-logger mwc-random
-         optparse-applicative parallel primitive template-haskell text time
-         transformers transformers-base vector zlib
+         aeson attoparsec base base16-bytestring bytestring
+         cryptohash-sha256 deepseq directory fast-logger hmatrix
+         monad-control monad-logger mwc-random optparse-applicative
+         primitive template-haskell text time transformers transformers-base
+         vector zlib
        ];
        description = "Tools for ELynx";
        license = stdenv.lib.licenses.gpl3Plus;
···
      }) {};
 
   "elynx-tree" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, comonad, containers
-     , criterion, deepseq, elynx-nexus, elynx-tools, hspec
-     , hspec-megaparsec, math-functions, megaparsec, mwc-random
-     , primitive, QuickCheck, statistics, vector
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad
+     , containers, criterion, deepseq, double-conversion, elynx-nexus
+     , elynx-tools, hspec, math-functions, mwc-random, primitive
+     , QuickCheck, statistics
      }:
      mkDerivation {
        pname = "elynx-tree";
-       version = "0.3.0";
-       sha256 = "10z7fm5ir91vh3j39kf2ylx02i4fvnwxzk7x9bfpp6f26cr0mfcb";
+       version = "0.3.1";
+       sha256 = "0ppah6lkzg39z80w30wicz88y4jpfj0z38py9y73srwvqy6a45l3";
        libraryHaskellDepends = [
-         aeson base bytestring comonad containers deepseq elynx-nexus
-         elynx-tools math-functions megaparsec mwc-random primitive
-         statistics vector
+         aeson attoparsec base bytestring comonad containers deepseq
+         double-conversion elynx-nexus math-functions mwc-random primitive
+         statistics
        ];
        testHaskellDepends = [
-         base bytestring containers elynx-tools hspec hspec-megaparsec
-         megaparsec QuickCheck
+         attoparsec base bytestring containers elynx-tools hspec QuickCheck
        ];
        benchmarkHaskellDepends = [
-         base bytestring containers criterion elynx-tools
+         base bytestring criterion elynx-tools
        ];
        description = "Handle phylogenetic trees";
        license = stdenv.lib.licenses.gpl3Plus;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "fgl_5_7_0_3" = callPackage
+    ({ mkDerivation, array, base, containers, deepseq, hspec
+     , microbench, QuickCheck, transformers
+     }:
+     mkDerivation {
+       pname = "fgl";
+       version = "5.7.0.3";
+       sha256 = "04k5grp5d381wkc7sxgcl0sd3z3nlm6l6mmh103vhzh6p49vhs99";
+       libraryHaskellDepends = [
+         array base containers deepseq transformers
+       ];
+       testHaskellDepends = [ base containers hspec QuickCheck ];
+       benchmarkHaskellDepends = [ base deepseq microbench ];
+       description = "Martin Erwig's Functional Graph Library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "fgl-arbitrary" = callPackage
     ({ mkDerivation, base, containers, fgl, hspec, QuickCheck }:
      mkDerivation {
        pname = "fgl-arbitrary";
-       version = "0.2.0.5";
-       sha256 = "1wp6v4wb2g6alq4r26da1zmc3g2g2xzca0znf4ldw4552azasaxx";
+       version = "0.2.0.6";
+       sha256 = "1mykbd1r43gpsn10ys8q3nr0i4wnhn6wq23hcici18mxxji11wkc";
        libraryHaskellDepends = [ base fgl QuickCheck ];
        testHaskellDepends = [ base containers fgl hspec QuickCheck ];
        description = "QuickCheck support for fgl";
···
      }) {};
 
   "filtrable" = callPackage
-    ({ mkDerivation, base }:
+    ({ mkDerivation, base, transformers }:
      mkDerivation {
        pname = "filtrable";
-       version = "0.1.3.0";
-       sha256 = "1viazb01xnw7siwrsynaxqcjrgc96gqfgmj4vxl5r3lbnb34wdl0";
-       revision = "1";
-       editedCabalFile = "15ghhsvd9r18ifrqh3x76p6hln4as185dnj5zzanbbfv684j9qsc";
-       libraryHaskellDepends = [ base ];
+       version = "0.1.4.0";
+       sha256 = "11jas9w611pslc3hanybsdwrh4292zvgigng8y4cv7gm0j908xng";
+       libraryHaskellDepends = [ base transformers ];
        description = "Class of filtrable containers";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "filtrable_0_1_4_0" = callPackage
-    ({ mkDerivation, base, transformers }:
+  "filtrable_0_1_5_0" = callPackage
+    ({ mkDerivation, base, smallcheck, tasty, tasty-smallcheck
+     , transformers
+     }:
      mkDerivation {
        pname = "filtrable";
-       version = "0.1.4.0";
-       sha256 = "11jas9w611pslc3hanybsdwrh4292zvgigng8y4cv7gm0j908xng";
+       version = "0.1.5.0";
+       sha256 = "0glarxd5yaflyhy8ni6q0kzrhgwi8msr3q4zf6by80g2qd33kvh8";
        libraryHaskellDepends = [ base transformers ];
+       testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ];
        description = "Class of filtrable containers";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "floskell";
-       version = "0.10.3";
-       sha256 = "07nr7grav7z378k3v14f21kji0hrgch0q1dwc00iw93zamanda2x";
+       version = "0.10.4";
+       sha256 = "14cwby2xyv2cviknpji6117jz6zfjrayrfvc75481g229yhcx156";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "foldl_1_4_7" = callPackage
+  "foldl_1_4_8" = callPackage
     ({ mkDerivation, base, bytestring, comonad, containers
      , contravariant, criterion, doctest, hashable, mwc-random
-     , primitive, profunctors, semigroupoids, semigroups, text
-     , transformers, unordered-containers, vector, vector-builder
+     , primitive, profunctors, semigroupoids, text, transformers
+     , unordered-containers, vector, vector-builder
      }:
      mkDerivation {
        pname = "foldl";
-       version = "1.4.7";
-       sha256 = "0pvdfzap9bv9v2n72gxy1xd1idyyz87h836bh09m84i8baasblxb";
+       version = "1.4.8";
+       sha256 = "1jlrcj9nq8xwlrsny6fzfizai3ilc1zbw38abgf35ryl23r5j6pd";
+       revision = "1";
+       editedCabalFile = "09jz01w3brgd8fwya56qgg0riv9vxzc0r9lkkhkx54nflari2rig";
        libraryHaskellDepends = [
          base bytestring comonad containers contravariant hashable
-         mwc-random primitive profunctors semigroupoids semigroups text
-         transformers unordered-containers vector vector-builder
+         mwc-random primitive profunctors semigroupoids text transformers
+         unordered-containers vector vector-builder
        ];
        testHaskellDepends = [ base doctest ];
        benchmarkHaskellDepends = [ base criterion ];
···
        pname = "fourmolu";
        version = "0.1.0.0";
        sha256 = "1kc7hhaqn7sghbcfj9xg8r1pvrmhawy9y2rhizfxzm7z034bgjyk";
+       revision = "1";
+       editedCabalFile = "1j6g6rzanjbdqf9svhjx0bbsy504xyc6vcn1ac3vgn4vp367wz0y";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }) {};
 
   "functor-combinators" = callPackage
-    ({ mkDerivation, base, bifunctors, comonad, constraints, containers
-     , dependent-sum, deriving-compat, free, hedgehog, kan-extensions
-     , mmorph, mtl, natural-transformation, nonempty-containers, pointed
-     , profunctors, semigroupoids, tagged, tasty, tasty-hedgehog, these
+    ({ mkDerivation, assoc, base, bifunctors, comonad, constraints
+     , containers, contravariant, dependent-sum, deriving-compat, free
+     , hedgehog, invariant, kan-extensions, mmorph, mtl
+     , natural-transformation, nonempty-containers, pointed, profunctors
+     , semigroupoids, sop-core, tagged, tasty, tasty-hedgehog, these
      , transformers, trivial-constraint, vinyl
      }:
      mkDerivation {
        pname = "functor-combinators";
-       version = "0.2.0.0";
-       sha256 = "0z8r9z08cayyv2ag748aa8550sd2mnj2zagdkf5i5yn3lvhd0k6j";
+       version = "0.3.0.0";
+       sha256 = "0bqlmxgq9as0ij11ir2licj3jkq190g56rdrf2g4hsjvk9xjsdkm";
        libraryHaskellDepends = [
-         base bifunctors comonad constraints containers deriving-compat free
-         kan-extensions mmorph mtl natural-transformation
-         nonempty-containers pointed profunctors semigroupoids tagged these
-         transformers trivial-constraint vinyl
+         assoc base bifunctors comonad constraints containers contravariant
+         deriving-compat free invariant kan-extensions mmorph mtl
+         natural-transformation nonempty-containers pointed profunctors
+         semigroupoids sop-core tagged these transformers trivial-constraint
+         vinyl
        ];
        testHaskellDepends = [
          base bifunctors dependent-sum free hedgehog nonempty-containers
-         semigroupoids tasty tasty-hedgehog transformers
+         semigroupoids tasty tasty-hedgehog transformers trivial-constraint
        ];
        description = "Tools for functor combinator-based program design";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "fused-effects-th";
-       version = "0.1.0.0";
-       sha256 = "05apm97hlk1k0h6px5sf25gwb6wnrg5za3z8r64rcxmzcfhd10c9";
+       version = "0.1.0.1";
+       sha256 = "0yr9gymqna0q47cv9j17cwgbbjc8sjf7f1lm8fbig5zybb6ycpm9";
        revision = "1";
-       editedCabalFile = "00zyzq1xz78vbnygayvc78i023xqib0k2p0qvxzx4d2908l36g6f";
+       editedCabalFile = "0slildsx3al8gn9s8w1dqq55pwsizjbkwmkm1vl742zk0kivax8c";
        libraryHaskellDepends = [ base fused-effects template-haskell ];
        testHaskellDepends = [
          base fused-effects tasty tasty-hunit template-haskell
···
        benchmarkHaskellDepends = [ base criterion deepseq ];
        description = "Deriving instances with GHC.Generics and related utilities";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "generic-data_0_9_0_0" = callPackage
+    ({ mkDerivation, ap-normalize, base, base-orphans, Cabal
+     , cabal-doctest, contravariant, criterion, deepseq, doctest
+     , generic-lens, ghc-boot-th, inspection-testing, one-liner
+     , QuickCheck, show-combinators, tasty, tasty-hunit
+     , template-haskell, unordered-containers
+     }:
+     mkDerivation {
+       pname = "generic-data";
+       version = "0.9.0.0";
+       sha256 = "1w8qkrl38p2fc38xbhgb973jd0czvm2f3707iqknj7rxf0xhjcfn";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         ap-normalize base base-orphans contravariant ghc-boot-th
+         show-combinators
+       ];
+       testHaskellDepends = [
+         base doctest generic-lens inspection-testing one-liner QuickCheck
+         show-combinators tasty tasty-hunit template-haskell
+         unordered-containers
+       ];
+       benchmarkHaskellDepends = [ base criterion deepseq ];
+       description = "Deriving instances with GHC.Generics and related utilities";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "generic-data-surgery" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "github-rest_1_0_3" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, base, bytestring, http-client
+     , http-client-tls, http-types, jwt, mtl, scientific, tasty
+     , tasty-golden, tasty-hunit, tasty-quickcheck, text, time
+     , transformers, unliftio, unliftio-core
+     }:
+     mkDerivation {
+       pname = "github-rest";
+       version = "1.0.3";
+       sha256 = "0alwix2lvrvv6ba7nrxg6qvvrdci1vbv94yvq29zmsab9lbv6jrb";
+       libraryHaskellDepends = [
+         aeson base bytestring http-client http-client-tls http-types jwt
+         mtl scientific text time transformers unliftio unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson aeson-qq base bytestring http-client http-client-tls
+         http-types jwt mtl scientific tasty tasty-golden tasty-hunit
+         tasty-quickcheck text time transformers unliftio unliftio-core
+       ];
+       description = "Query the GitHub REST API programmatically";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "github-tools" = callPackage
     ({ mkDerivation, base, bytestring, containers, exceptions, github
      , groom, html, http-client, http-client-tls, monad-parallel
···
        license = stdenv.lib.licenses.bsd3;
      }) {inherit (pkgs) graphviz;};
 
+  "graphviz_2999_20_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, colour, containers, criterion
+     , deepseq, directory, dlist, fgl, fgl-arbitrary, filepath, graphviz
+     , hspec, hspec-discover, mtl, polyparse, process, QuickCheck
+     , temporary, text, wl-pprint-text
+     }:
+     mkDerivation {
+       pname = "graphviz";
+       version = "2999.20.1.0";
+       sha256 = "0l0zxgb938hh09qirggbaskq79mgj3s081cnr42y5vm1rp1jir2s";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring colour containers directory dlist fgl filepath mtl
+         polyparse process temporary text wl-pprint-text
+       ];
+       testHaskellDepends = [
+         base containers fgl fgl-arbitrary filepath hspec QuickCheck text
+       ];
+       testSystemDepends = [ graphviz ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base criterion deepseq text ];
+       description = "Bindings to Graphviz for graph visualisation";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs) graphviz;};
+
   "graql" = callPackage
     ({ mkDerivation, aeson, base, containers, hspec, markdown-unlit
      , process, regex-posix, scientific, text
···
      }) {};
 
   "hal" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, envy
-     , exceptions, http-conduit, http-types, mtl, text, time
+    ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
+     , containers, envy, exceptions, http-client, http-conduit
+     , http-types, mtl, text, time
      }:
      mkDerivation {
        pname = "hal";
-       version = "0.4.3";
-       sha256 = "0iqyayya1j3l1jrb2i68shn4zgrqf63pv3l9v29s0chn3gyyij1r";
+       version = "0.4.4";
+       sha256 = "0nqxlvbk8lb9c6hh15gn8nd9h2p0rcrllkqjli0ixqil3qpynl76";
        libraryHaskellDepends = [
-         aeson base bytestring containers envy exceptions http-conduit
-         http-types mtl text time
+         aeson base bytestring conduit conduit-extra containers envy
+         exceptions http-client http-conduit http-types mtl text time
        ];
        description = "A runtime environment for Haskell applications running on AWS Lambda";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "happy-meta";
-       version = "0.2.0.10";
-       sha256 = "1w6shcydpca5g9dgnki0w2xqr9mf17xa18s8hxxm3z3dd0sp1db9";
+       version = "0.2.0.11";
+       sha256 = "1vgv5fx1fya7wfh3zwdgy0hm0lyzp171gnpp6ymfd6kqmqkl3293";
        libraryHaskellDepends = [
          array base containers fail haskell-src-meta mtl template-haskell
        ];
···
      }:
      mkDerivation {
        pname = "harg";
-       version = "0.4.2.0";
-       sha256 = "14a5d73klg7da1pg30as9xnky95jxh1kl0qrzihvgd5m2kybsrb0";
+       version = "0.4.2.1";
+       sha256 = "0fbbf9zxfbyc6mnsybrd81sd87ps6qwks5zv5kmjygc6w8ngh6vh";
        libraryHaskellDepends = [
          aeson barbies base bytestring directory higgledy
          optparse-applicative split text yaml
···
 
   "hascard" = callPackage
     ({ mkDerivation, base, brick, containers, directory, filepath
-     , microlens, microlens-platform, mwc-random, optparse-applicative
-     , ordered-containers, parsec, process, random-fu, strict, text
-     , vector, vty, word-wrap
+     , megaparsec, microlens, microlens-platform, mwc-random
+     , optparse-applicative, ordered-containers, process, random-fu
+     , strict, text, vector, vty, word-wrap
      }:
      mkDerivation {
        pname = "hascard";
-       version = "0.2.0.0";
-       sha256 = "1khdlkf2n6x3rck9sc7jir08mx7n7dv9p25j80g27q6a1nm0pq91";
+       version = "0.2.1.0";
+       sha256 = "13f7vmdrd3ibr78pjy7144qj0qa8s07k4j341fzw8w8af83m9wvc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base brick containers directory filepath microlens
+         base brick containers directory filepath megaparsec microlens
          microlens-platform mwc-random optparse-applicative
-         ordered-containers parsec process random-fu strict text vector vty
+         ordered-containers process random-fu strict text vector vty
          word-wrap
        ];
        executableHaskellDepends = [
-         base brick containers directory filepath microlens
+         base brick containers directory filepath megaparsec microlens
          microlens-platform mwc-random optparse-applicative
-         ordered-containers parsec process random-fu strict text vector vty
+         ordered-containers process random-fu strict text vector vty
          word-wrap
        ];
        testHaskellDepends = [
-         base brick containers directory filepath microlens
+         base brick containers directory filepath megaparsec microlens
          microlens-platform mwc-random optparse-applicative
-         ordered-containers parsec process random-fu strict text vector vty
+         ordered-containers process random-fu strict text vector vty
          word-wrap
        ];
        description = "A TUI for reviewing notes using 'flashcards' written with markdown-like syntax";
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.37.3";
-       sha256 = "1gkgznvx0y30568l2rs0px2pfyzn9sbzqv9vnd5ps5ib33yb853s";
+       version = "0.37.5";
+       sha256 = "0ac1znif59fzcxcl3nmvrv6v49rzlcgsv138zgjnk7zxarp8alyg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskoin-store-data";
-       version = "0.37.3";
-       sha256 = "1wz0nwm4izsxaxij9s4vfjdlcqp1jca16g2phdn3k2dp35kyfymi";
+       version = "0.37.5";
+       sha256 = "1p8hsnwr0h0sbnwg1kwbal36q4bh3s0daz1a5n2c8xal5xdkbdra";
        libraryHaskellDepends = [
          aeson base bytestring cereal containers data-default deepseq
          hashable haskoin-core http-client http-types lens mtl network
···
      }:
      mkDerivation {
        pname = "hedgehog-classes";
-       version = "0.2.5";
-       sha256 = "0rr9d3xajdlfmx92klq1zyi55wrc5ivf2p1jb0a6vxpyk75gy8wg";
+       version = "0.2.5.1";
+       sha256 = "0gyq9dr25sz14yw5x8jlb73l2hzv92r1c6cfan7lygq7z0yaiw6b";
        libraryHaskellDepends = [
          aeson base binary comonad containers hedgehog pretty-show primitive
          semirings silently transformers vector wl-pprint-annotated
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "hextra";
-       version = "0.3.0.3";
-       sha256 = "1vqx8wqac0xy1h2g36ylhyikqw9rd1m2704z27vc97g58vmhxbli";
+       version = "1.0.0.0";
+       sha256 = "17ik20q07if3gvfsifm00k8z6iffcjwmy19n5xyzzc4bd17qffzb";
        libraryHaskellDepends = [ base ];
        description = "Generic and niche utility functions and more for Haskell";
        license = stdenv.lib.licenses.mpl20;
···
      }:
      mkDerivation {
        pname = "hgrev";
-       version = "0.2.5";
-       sha256 = "06ikaxxa70x71w4rq7a9rcp4mj12d8wlwzfdxnrapg9x9yr3py85";
+       version = "0.2.6";
+       sha256 = "1v1niqvqj6w8nkr3pmjwj7va2f2nv8miwsfqsp3lj3b2i9x6asb2";
        libraryHaskellDepends = [
          aeson base bytestring directory filepath process template-haskell
        ];
···
      }) {};
 
   "hkgr" = callPackage
-    ({ mkDerivation, base, directory, extra, filepath, simple-cabal
-     , simple-cmd, simple-cmd-args, xdg-basedir
-     }:
-     mkDerivation {
-       pname = "hkgr";
-       version = "0.2.6";
-       sha256 = "0wjq88cg84jiy3mqwhsamd6q57y76fqpyq27yq5jb30w3wrp4wdv";
-       isLibrary = false;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       executableHaskellDepends = [
-         base directory extra filepath simple-cabal simple-cmd
-         simple-cmd-args xdg-basedir
-       ];
-       description = "Simple Hackage release workflow for package maintainers";
-       license = stdenv.lib.licenses.gpl3;
-     }) {};
-
-  "hkgr_0_2_6_1" = callPackage
     ({ mkDerivation, base, directory, extra, filepath, simple-cabal
      , simple-cmd, simple-cmd-args, xdg-basedir
      }:
···
        ];
        description = "Simple Hackage release workflow for package maintainers";
        license = stdenv.lib.licenses.gpl3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hkt" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hs-functors_0_1_7_1" = callPackage
+    ({ mkDerivation, base, dual, tagged, transformers }:
+     mkDerivation {
+         directory filepath hashable lazy-hash microlens microlens-th
+       version = "0.1.7.1";
+       sha256 = "1cigaggilr05pgizj11g5c40ln38zb5q8p0igliamkhx7fz3axis";
+       libraryHaskellDepends = [ base dual tagged transformers ];
+         directory filepath hashable lazy-hash microlens microlens-th
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
          directory filepath hashable lazy-hash microlens microlens-th
     ({ mkDerivation, base, mtl }:
      mkDerivation {
···
 
          directory filepath hashable lazy-hash microlens microlens-th
          directory filepath hashable lazy-hash microlens microlens-th
-     , smallcheck, tasty, tasty-smallcheck, util
-     }:
      mkDerivation {
          directory filepath hashable lazy-hash microlens microlens-th
-       version = "0.1.1.0";
-         directory filepath hashable lazy-hash microlens microlens-th
-       libraryHaskellDepends = [
-         directory filepath hashable lazy-hash microlens microlens-th
-       ];
-       testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ];
-       benchmarkHaskellDepends = [ base criterion ];
-         directory filepath hashable lazy-hash microlens microlens-th
+       version = "0.2.0.0";
+       sha256 = "04dm8c5ilaw4agljfp7k31ln2j5m1shyg4zb3x36rjkbs807z8sf";
+       libraryHaskellDepends = [ base hs-functors ];
+       description = "Indexed applicative functors and monads";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "hspec-golden_0_1_0_3" = callPackage
+         directory filepath hashable lazy-hash microlens microlens-th
+         directory filepath hashable lazy-hash microlens microlens-th
+     }:
+     mkDerivation {
+         directory filepath hashable lazy-hash microlens microlens-th
+       version = "0.1.0.3";
+       sha256 = "1d5ab34n0f1wk1q86qlb7x2b49abzzh08jh7j52nbrvnxld2j64l";
+       isLibrary = true;
+       isExecutable = true;
+         directory filepath hashable lazy-hash microlens microlens-th
+         directory filepath hashable lazy-hash microlens microlens-th
+         directory filepath hashable lazy-hash microlens microlens-th
+         directory filepath hashable lazy-hash microlens microlens-th
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
          directory filepath hashable lazy-hash microlens microlens-th
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, directory
          directory filepath hashable lazy-hash microlens microlens-th
···
      }:
      mkDerivation {
          directory filepath hashable lazy-hash microlens microlens-th
-       version = "0.3";
-         directory filepath hashable lazy-hash microlens microlens-th
-       revision = "1";
-         directory filepath hashable lazy-hash microlens microlens-th
+       version = "0.3.1";
+       sha256 = "0pcx1s15ijdj5kxqbwcqf5qvpa8wxac9ph5013cmg1k1yflnqrzh";
        libraryHaskellDepends = [
          directory filepath hashable lazy-hash microlens microlens-th
        ];
···
      }:
      mkDerivation {
        pname = "http-streams";
-       version = "0.8.7.1";
-       sha256 = "0kl668ggxz5wzvziagw9inmmwb0l5x2r00nf4p7wm0pnl8m19l2b";
-       libraryHaskellDepends = [
-         aeson attoparsec base base64-bytestring blaze-builder bytestring
-         case-insensitive directory HsOpenSSL http-common io-streams mtl
-         network network-uri openssl-streams text transformers
-         unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson aeson-pretty attoparsec base base64-bytestring blaze-builder
-         bytestring case-insensitive directory ghc-prim HsOpenSSL hspec
-         hspec-expectations http-common HUnit io-streams lifted-base mtl
-         network network-uri openssl-streams snap-core snap-server
-         system-fileio system-filepath text transformers
-         unordered-containers
-       ];
-       description = "An HTTP client using io-streams";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "http-streams_0_8_7_2" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base
-     , base64-bytestring, blaze-builder, bytestring, case-insensitive
-     , directory, ghc-prim, HsOpenSSL, hspec, hspec-expectations
-     , http-common, HUnit, io-streams, lifted-base, mtl, network
-     , network-uri, openssl-streams, snap-core, snap-server
-     , system-fileio, system-filepath, text, transformers
-     , unordered-containers
-     }:
-     mkDerivation {
-       pname = "http-streams";
        version = "0.8.7.2";
        sha256 = "1q0lp8hkzfc0srci9y794q5cqkih50r3iw2c32wbx8h502jcvv1q";
        libraryHaskellDepends = [
···
        ];
        description = "An HTTP client using io-streams";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "http-test" = callPackage
···
        pname = "hyper";
        version = "0.1.0.3";
        sha256 = "0bc2mvxaggdyikdx51qc1li8idmnlw3ha2n3qli6jf1zz8mlqx0s";
+       revision = "1";
+       editedCabalFile = "1qfavgvdlmsip57grhxs0mawh82nxrq4m0mv9z3vam1b9j6nw2cc";
        libraryHaskellDepends = [ base blaze-html deepseq text ];
        description = "Display class for the HyperHaskell graphical Haskell interpreter";
        license = stdenv.lib.licenses.bsd3;
···
     ({ mkDerivation, base, ghc-prim, transformers }:
      mkDerivation {
        pname = "icfpc2020-galaxy";
-       version = "0.1.0.1";
-       sha256 = "1nd925iwyy73imw2h0xa3n9vi8rr487v541l9mlb834l20v6mpzl";
+       version = "0.2.0.0";
+       sha256 = "17m8vp3kikpscagb40972r9a8i6ng8wjc697zdslj5zl95rpyrvd";
        libraryHaskellDepends = [ base ghc-prim transformers ];
        description = "A strange message received at the Pegovka observatory";
        license = stdenv.lib.licenses.mit;
···
        broken = true;
      }) {};
 
+  "jsop" = callPackage
+    ({ mkDerivation, aeson, base, containers, generics-sop, lens
+     , lens-aeson, monoidal-containers, protolude, string-interpolate
+     , tasty, tasty-discover, tasty-hspec, text
+     }:
+     mkDerivation {
+       pname = "jsop";
+       version = "0.1.0.0";
+       sha256 = "0yaxcpxgn00jf3igvncg59ca6hz28sf791872n617v3vh7arv8y3";
+       libraryHaskellDepends = [
+         aeson base containers generics-sop lens lens-aeson
+         monoidal-containers protolude string-interpolate tasty
+         tasty-discover tasty-hspec text
+       ];
+       testHaskellDepends = [
+         aeson base containers generics-sop lens lens-aeson
+         monoidal-containers protolude string-interpolate tasty
+         tasty-discover tasty-hspec text
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Cherry picking in JSON objects";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "jspath" = callPackage
     ({ mkDerivation, base, bytestring, bytestring-trie, JSONb
      , utf8-string
···
      }:
      mkDerivation {
        pname = "knit";
-       version = "0.1.0.0";
-       sha256 = "0ypa7bj89zbkgyryms6nzwhqpp15hs52ynjvisdsng1xpgmf65dy";
+       version = "0.2.0.0";
+       sha256 = "0a1swv5w9fxissxqr2x61qijqyhdxs71fv21fjz4r0kcqywnvy6x";
        libraryHaskellDepends = [
          base bytestring containers deepseq hashtables vector
        ];
···
      }:
      mkDerivation {
        pname = "language-dickinson";
-       version = "1.1.0.1";
-       sha256 = "0j163whdxpzi2aklb5x7f42y61whm941x0rjls02crgmpdaj0z75";
+       version = "1.1.0.2";
+       sha256 = "1g2d32535vmgjiy1ld4hq8g5il98c3h6ykfdl34fq8329qf9gxxr";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "lsp-test_0_11_0_3" = callPackage
+  "lsp-test_0_11_0_4" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async, base
      , bytestring, conduit, conduit-parse, containers, data-default
      , Diff, directory, filepath, Glob, haskell-lsp, hspec, lens, mtl
···
      }:
      mkDerivation {
        pname = "lsp-test";
-       version = "0.11.0.3";
-       sha256 = "065g80nbiw9lrk4rjnbksrnjc79klxxl8vxvpmcsinqmvxcynm8f";
+       version = "0.11.0.4";
+       sha256 = "0nf0ys44q2n81arg7ll08dkilq8giz0gxarld2lpq5fyhhfvyv7g";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, lucid }:
      mkDerivation {
        pname = "lucid-cdn";
-       version = "0.1.1.0";
-       sha256 = "1z70mgwa3krd9a4za32psdnqzrvqb9205saqfhxpkny8sd2g14rc";
+       version = "0.1.1.1";
+       sha256 = "1dl44rc5b3wrgfcllp6h1sw4w18jgglh1grh5w9g37rcxi2cxwll";
        libraryHaskellDepends = [ base lucid ];
        description = "Curated list of CDN imports for lucid";
        license = stdenv.lib.licenses.mit;
···
        broken = true;
      }) {};
 
+  "matrix-as-xyz_0_1_2_1" = callPackage
+    ({ mkDerivation, base, doctest, hspec, matrix, parsec, QuickCheck
+     }:
+     mkDerivation {
+       pname = "matrix-as-xyz";
+       version = "0.1.2.1";
+       sha256 = "0k49k16mxp7izkanan0yrrlkzvblw1w7bvfrh486fys83gvkb3x8";
+       libraryHaskellDepends = [ base doctest hspec matrix parsec ];
+       testHaskellDepends = [
+         base doctest hspec matrix parsec QuickCheck
+       ];
+       description = "Read and Display Jones-Faithful notation for spacegroup and planegroup";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "matrix-lens" = callPackage
     ({ mkDerivation, base, hedgehog, lens, matrix, tasty
      , tasty-discover, tasty-hedgehog, tasty-hspec, vector
···
 
   "mcmc" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, criterion
-     , data-default, directory, hspec, hspec-discover, log-domain
-     , microlens, mwc-random, QuickCheck, statistics, text, time
+     , data-default, directory, double-conversion, hspec, hspec-discover
+     , log-domain, microlens, mwc-random, QuickCheck, statistics, time
      , transformers, vector, zlib
      }:
      mkDerivation {
        pname = "mcmc";
-       version = "0.2.0";
-       sha256 = "1nybslnvn9g6cha19m2xhs6nba5nap572yxhgv4bjv44dmr6lvf7";
+       version = "0.2.1";
+       sha256 = "1jh88xqi485ha3bqrp012xsv7cljwsaxxc45l5npcr947g22ln11";
        libraryHaskellDepends = [
-         aeson base bytestring containers data-default directory log-domain
-         microlens mwc-random statistics text time transformers vector zlib
+         aeson base bytestring containers data-default directory
+         double-conversion log-domain microlens mwc-random statistics time
+         transformers vector zlib
        ];
        testHaskellDepends = [
          base directory hspec hspec-discover log-domain mwc-random
···
        ];
        testToolDepends = [ hspec-discover ];
        benchmarkHaskellDepends = [
-         base criterion log-domain microlens mwc-random statistics text
-         vector
+         base criterion log-domain microlens mwc-random statistics vector
        ];
        description = "Sample from a posterior using Markov chain Monte Carlo";
        license = stdenv.lib.licenses.gpl3Plus;
···
        broken = true;
      }) {};
 
+  "mealy" = callPackage
+    ({ mkDerivation, adjunctions, backprop, base, containers, doctest
+     , folds, generic-lens, hmatrix, lens, mwc-probability, mwc-random
+     , numhask, numhask-array, primitive, profunctors, tdigest, text
+     , vector, vector-algorithms
+     }:
+     mkDerivation {
+       pname = "mealy";
+       version = "0.0.1";
+       sha256 = "0z7hf1blzhgrjmrf7s2dpgmg73157j476g17i7m52zgfgq4vmym9";
+       libraryHaskellDepends = [
+         adjunctions backprop base containers folds generic-lens hmatrix
+         lens mwc-probability mwc-random numhask numhask-array primitive
+         profunctors tdigest text vector vector-algorithms
+       ];
+       testHaskellDepends = [ base doctest numhask ];
+       description = "See readme.md";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "means" = callPackage
     ({ mkDerivation, base, semigroups }:
      mkDerivation {
···
        ];
        description = "A schema language for JSON";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "medea_1_2_0" = callPackage
+    ({ mkDerivation, aeson, algebraic-graphs, base, bytestring
+     , containers, deepseq, directory, filepath, free, hashable, hspec
+     , hspec-core, megaparsec, microlens-ghc, mtl, nonempty-containers
+     , parser-combinators, QuickCheck, quickcheck-instances, scientific
+     , smash, text, unordered-containers, vector, vector-instances
+     }:
+     mkDerivation {
+       pname = "medea";
+       version = "1.2.0";
+       sha256 = "019jfz29gz3d06b5yi7fygqa79lp6c6vbzxcb5ka7d8w0zv7w60v";
+       libraryHaskellDepends = [
+         aeson algebraic-graphs base bytestring containers deepseq free
+         hashable megaparsec microlens-ghc mtl nonempty-containers
+         parser-combinators scientific smash text unordered-containers
+         vector vector-instances
+       ];
+       testHaskellDepends = [
+         aeson base bytestring directory filepath hspec hspec-core mtl
+         QuickCheck quickcheck-instances text unordered-containers vector
+       ];
+       description = "A schema language for JSON";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "mediabus" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "mixed-types-num_0_4_0_2" = callPackage
+    ({ mkDerivation, base, hspec, hspec-smallcheck, mtl, QuickCheck
+     , smallcheck, template-haskell
+     }:
+     mkDerivation {
+       pname = "mixed-types-num";
+       version = "0.4.0.2";
+       sha256 = "0kirxpnmwwnbxamwpzrxyx69n482xhifqpr5id73pfni7lrd126p";
+       libraryHaskellDepends = [
+         base hspec hspec-smallcheck mtl QuickCheck smallcheck
+         template-haskell
+       ];
+       testHaskellDepends = [ base hspec hspec-smallcheck QuickCheck ];
+       description = "Alternative Prelude with numeric and logic expressions typed bottom-up";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "mixpanel-client" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring, hspec
      , hspec-discover, http-client, http-client-tls, markdown-unlit
···
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
+     }) {};
+
+  "mock-httpd" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, case-insensitive
+     , filepath, http-types, relude, text, wai, warp, yaml
+     }:
+     mkDerivation {
+       pname = "mock-httpd";
+       version = "0.0.0.0";
+       sha256 = "0mv669gvn61by4j7sd4w2hvzr3vpa0szrhgzdciv5g1a0gsh3kk7";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson async base bytestring case-insensitive filepath http-types
+         relude text wai warp yaml
+       ];
+       description = "A HTTP server for testing HTTP clients";
+       license = stdenv.lib.licenses.bsd2;
      }) {};
 
   "mockazo" = callPackage
···
      }:
      mkDerivation {
        pname = "mwc-probability";
-       version = "2.3.0";
-       sha256 = "1rk5n015a24bv49m2qnc66iv5hcw99zk9zflqv99pxxbpia6kiyj";
+       version = "2.3.1";
+       sha256 = "15gpvx1rhr24zvj6pfgyy9g2vnhgym5crmz4py3nly2jcmy9k39z";
        libraryHaskellDepends = [
          base containers mwc-random primitive transformers
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "network_3_1_2_0" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, directory, hspec
+     , hspec-discover, HUnit, QuickCheck, temporary
+     }:
+     mkDerivation {
+       pname = "network";
+       version = "3.1.2.0";
+       sha256 = "07zbaaa4f0rnc4xqg5kbzqivmr9lqz2g6bw01gmqkmh9k9svsap0";
+       libraryHaskellDepends = [ base bytestring deepseq directory ];
+       testHaskellDepends = [
+         base bytestring directory hspec HUnit QuickCheck temporary
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Low-level networking interface";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "network-address" = callPackage
     ({ mkDerivation, base, Cabal, QuickCheck, test-framework
      , test-framework-quickcheck2
···
      }:
      mkDerivation {
        pname = "ngx-export-tools-extra";
-       version = "0.5.4.1";
-       sha256 = "153dswxwzai2fgn7k164zm1j2n144rncjyxj1k76mg9bqggplahs";
+       version = "0.5.5.0";
+       sha256 = "1w7vm0sic1v4zy10m8rkzrgbkvn3wnb4320gkl2dclsfdk70d5b3";
        libraryHaskellDepends = [
          aeson ansi-wl-pprint array base base64 binary bytestring
          case-insensitive containers ede enclosed-exceptions http-client
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "nonempty-containers_0_3_4_0" = callPackage
+    ({ mkDerivation, aeson, base, comonad, containers, deepseq
+     , hedgehog, hedgehog-fn, nonempty-vector, semigroupoids, tasty
+     , tasty-hedgehog, text, these, vector
+     }:
+     mkDerivation {
+       pname = "nonempty-containers";
+       version = "0.3.4.0";
+       sha256 = "1np8gypq49j90clavh17wzxp9y6z23lngal815jsg4p35qc0h01l";
+       libraryHaskellDepends = [
+         aeson base comonad containers deepseq nonempty-vector semigroupoids
+         these vector
+       ];
+       testHaskellDepends = [
+         base comonad containers hedgehog hedgehog-fn nonempty-vector
+         semigroupoids tasty tasty-hedgehog text these vector
+       ];
+       description = "Non-empty variants of containers data types, with full API";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "nonempty-lift" = callPackage
     ({ mkDerivation, base, comonad, hedgehog, hedgehog-classes
      , semigroupoids
···
 
   "numhask-space" = callPackage
     ({ mkDerivation, adjunctions, base, containers, distributive
-     , doctest, foldl, lattices, protolude, semigroupoids, tdigest, text
-     , time
+     , doctest, numhask, semigroupoids, tdigest, text, time
      }:
      mkDerivation {
        pname = "numhask-space";
-       version = "0.5.0";
-       sha256 = "0ygx5qkmsxf9qr1kbv96aqcm2rwb20v57zkn62ibhp01adj8n1gs";
+       version = "0.6.0";
+       sha256 = "0zm64spljv7pvl68b60y7hr46fa82i44j7yk8q6i33nhr78qv7wy";
        libraryHaskellDepends = [
-         adjunctions base containers distributive foldl lattices protolude
-         semigroupoids tdigest text time
+         adjunctions base containers distributive numhask semigroupoids
+         tdigest text time
        ];
-       testHaskellDepends = [ base doctest protolude ];
+       testHaskellDepends = [ base doctest numhask ];
        description = "numerical spaces";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "opaleye_0_6_7005_0" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , case-insensitive, containers, contravariant, dotenv, hspec
+     , hspec-discover, multiset, postgresql-simple, pretty
+     , product-profunctors, profunctors, QuickCheck, scientific
+     , semigroups, text, time, time-locale-compat, transformers, uuid
+     , void
+     }:
+     mkDerivation {
+       pname = "opaleye";
+       version = "0.6.7005.0";
+       sha256 = "0i5lwfvj7382ayxzdbip1nwjiiy7jn58g7qa33s44x3pnjv3wssy";
+       revision = "1";
+       editedCabalFile = "0bby89fvbx89b882b2qx07lg8npnfa325qg0gyabrd950510vzr2";
+       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
···
      }:
      mkDerivation {
        pname = "opml-conduit";
-       version = "0.8.0.0";
-       sha256 = "08j6hm605km4j3w9n8mbwlzhz8avy3m941wgr9rp5dfkasi3s9p3";
+       version = "0.9.0.0";
+       sha256 = "012cnq24dhsiz6dfm23i1kac2pya50x2gj42cvcdhr8navz7czcb";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base case-insensitive conduit conduit-combinators containers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "optics-core_0_3" = callPackage
+  "optics-core_0_3_0_1" = callPackage
     ({ mkDerivation, array, base, containers, indexed-profunctors
      , transformers
      }:
      mkDerivation {
        pname = "optics-core";
-       version = "0.3";
-       sha256 = "0gjxbrgp7c9k40782i2hm0pmb4fdrzcwbkq1xsj1835xszzxlp8n";
+       version = "0.3.0.1";
+       sha256 = "01z1rjrmj3jqh3fygqa1asr4azhdnqpix27sdw3ygi5dnbcmn49h";
        libraryHaskellDepends = [
          array base containers indexed-profunctors transformers
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "optics-th_0_3" = callPackage
+  "optics-th_0_3_0_1" = callPackage
     ({ mkDerivation, base, containers, mtl, optics-core, tagged
      , template-haskell, th-abstraction, transformers
      }:
      mkDerivation {
        pname = "optics-th";
-       version = "0.3";
-       sha256 = "1k8kwii9jn1gjswkf7p5j5yvq7p9z8rs09ak78s5lmvxkh4c7035";
+       version = "0.3.0.1";
+       sha256 = "1bn9yhl1v4xkagasgiq4v572v4vvbk40wwlx9wjdw0gqcisy4b3j";
        libraryHaskellDepends = [
          base containers mtl optics-core template-haskell th-abstraction
          transformers
···
     ({ mkDerivation, base, mtl }:
      mkDerivation {
        pname = "optparse-declarative";
-       version = "0.3.0";
-       sha256 = "1avy0g6jk34jbfp1xzqcyhb4j53knsbzx1pssl4b5f6nn981mbj8";
+       version = "0.3.1";
+       sha256 = "1s3bkkn5a8bgkbqdsf5ir18r0j0r2r0agz04q2ccafd26d8xdx2s";
        libraryHaskellDepends = [ base mtl ];
        description = "Declarative command line option parser";
        license = stdenv.lib.licenses.mit;
···
        pname = "pandoc-citeproc";
        version = "0.17.0.1";
        sha256 = "0hi31h4jxamnyw0jsbwnbzy9gkp3a03mhsgwy9w73hi13lywxrgk";
+       revision = "1";
+       editedCabalFile = "0z1gnaagylsjx8f1i49bp4zhcx2hlkc3w9wkwzsvvjq0qcfgzis0";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "pandoc-citeproc_0_17_0_2" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
+     , Cabal, containers, data-default, directory, filepath, hs-bibutils
+     , HsYAML, HsYAML-aeson, libyaml, mtl, network, old-locale, pandoc
+     , pandoc-types, parsec, process, rfc5051, safe, setenv, split, syb
+     , tagsoup, temporary, text, time, unordered-containers, vector
+     , xml-conduit, yaml
+     }:
+     mkDerivation {
+       pname = "pandoc-citeproc";
+       version = "0.17.0.2";
+       sha256 = "1wp16zz740klyn5jr8qxn21zf1waym3pzzv5l6k08w2l6z54d20b";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [
+         aeson base bytestring containers data-default directory filepath
+         hs-bibutils HsYAML HsYAML-aeson mtl network old-locale pandoc
+         pandoc-types parsec rfc5051 setenv split syb tagsoup text time
+         unordered-containers vector xml-conduit yaml
+       ];
+       executableHaskellDepends = [
+         aeson aeson-pretty attoparsec base bytestring filepath libyaml
+         pandoc pandoc-types safe syb text yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers directory filepath mtl pandoc
+         pandoc-types process temporary text yaml
+       ];
+       doCheck = false;
+       description = "Supports using pandoc with citeproc";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "pandoc-citeproc-preamble" = callPackage
     ({ mkDerivation, base, directory, filepath, pandoc-types, process
      , text-conversions
···
        broken = true;
      }) {};
 
-  "pandoc-plot_0_8_1_0" = callPackage
+  "pandoc-plot_0_9_0_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.8.1.0";
-       sha256 = "11mn2baqya3xm325znxcsxglv6ydd67yd69p3fvqn9m2fcg1y9fr";
+       version = "0.9.0.0";
+       sha256 = "0wamycf3cbblcifs7sppnzg4vbglzgizmjb5idg0dgkhlrk78gcx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "pgf2" = callPackage
+    ({ mkDerivation, base, containers, gu, pgf, pretty }:
+     mkDerivation {
+       pname = "pgf2";
+       version = "1.2.0";
+       sha256 = "1lw9wdsvlasd5x323dficcmzqf48yz49wd3v64gsyx60sw93vn0y";
+       libraryHaskellDepends = [ base containers pretty ];
+       librarySystemDepends = [ gu pgf ];
+       description = "Bindings to the C version of the PGF runtime";
+       license = stdenv.lib.licenses.lgpl3;
+     }) {gu = null; inherit (pkgs) pgf;};
+
   "pgm" = callPackage
     ({ mkDerivation, array, base, bytestring, parsec }:
      mkDerivation {
···
        ];
        description = "Compositional pipelines";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "pipes_4_3_14" = callPackage
+    ({ mkDerivation, base, criterion, exceptions, mmorph, mtl
+     , optparse-applicative, QuickCheck, test-framework
+     , test-framework-quickcheck2, transformers, void
+     }:
+     mkDerivation {
+       pname = "pipes";
+       version = "4.3.14";
+       sha256 = "11r8cqy98w1y0avgn53x1fzqxpdfg7wvwwkfppnk9yip0lkcp3yv";
+       libraryHaskellDepends = [
+         base exceptions mmorph mtl transformers void
+       ];
+       testHaskellDepends = [
+         base mtl QuickCheck test-framework test-framework-quickcheck2
+         transformers
+       ];
+       benchmarkHaskellDepends = [
+         base criterion mtl optparse-applicative transformers
+       ];
+       description = "Compositional pipelines";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "pipes-aeson" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "postgresql-tx" = callPackage
+    ({ mkDerivation, base, transformers }:
+     mkDerivation {
+       pname = "postgresql-tx";
+       version = "0.1.0.0";
+       sha256 = "1jvrdyllmgd0v9w2wxqr1g70f6gza1wyb13j38ww2r2nvqzhp330";
+       libraryHaskellDepends = [ base transformers ];
+       description = "A safe transaction monad for use with various PostgreSQL Haskell libraries";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "postgresql-tx-monad-logger" = callPackage
+    ({ mkDerivation, base, monad-logger, postgresql-tx }:
+     mkDerivation {
+       pname = "postgresql-tx-monad-logger";
+       version = "0.1.0.0";
+       sha256 = "0y1x2d2r61ayhln0l2c5i3ivv97zpwyiaw1hymghpv4vwnlihv1y";
+       libraryHaskellDepends = [ base monad-logger postgresql-tx ];
+       description = "postgresql-tx interfacing for use with monad-logger";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "postgresql-tx-query" = callPackage
+    ({ mkDerivation, base, monad-logger, mtl, postgresql-query
+     , postgresql-simple, postgresql-tx, postgresql-tx-monad-logger
+     , transformers
+     }:
+     mkDerivation {
+       pname = "postgresql-tx-query";
+       version = "0.1.0.0";
+       sha256 = "0a7khw9ncc8k5cpi63kw598hvg3ycm1lchz46aw06pndcdzr54sv";
+       libraryHaskellDepends = [
+         base monad-logger mtl postgresql-query postgresql-simple
+         postgresql-tx postgresql-tx-monad-logger transformers
+       ];
+       description = "postgresql-tx interfacing for use with postgresql-query";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "postgresql-tx-simple" = callPackage
+    ({ mkDerivation, base, postgresql-simple, postgresql-tx
+     , transformers
+     }:
+     mkDerivation {
+       pname = "postgresql-tx-simple";
+       version = "0.1.0.0";
+       sha256 = "1k03wqqzsvmmd7wh9gnlg9h12v2xnzd1vc9396sl1krg29l8373p";
+       libraryHaskellDepends = [
+         base postgresql-simple postgresql-tx transformers
+       ];
+       description = "postgresql-tx interfacing for use with postgresql-simple";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "postgresql-tx-squeal" = callPackage
+    ({ mkDerivation, base, bytestring, generics-sop, postgresql-libpq
+     , postgresql-tx, records-sop, squeal-postgresql
+     }:
+     mkDerivation {
+       pname = "postgresql-tx-squeal";
+       version = "0.1.0.0";
+       sha256 = "08wfdy6hlpwkv3njh33igskv489kk8zbsd1nk24fvql1w215gsa4";
+       libraryHaskellDepends = [
+         base bytestring generics-sop postgresql-libpq postgresql-tx
+         records-sop squeal-postgresql
+       ];
+       description = "postgresql-tx interfacing for use with squeal-postgresql";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "postgresql-typed" = callPackage
     ({ mkDerivation, aeson, array, attoparsec, base, binary, bytestring
      , containers, convertible, criterion, cryptonite, data-default
···
      }:
      mkDerivation {
        pname = "postgresql-typed";
-       version = "0.6.1.1";
-       sha256 = "002bqsvsig6232d4di811rpjyjg7r45xsywb34i9l98imh51mia1";
+       version = "0.6.1.2";
+       sha256 = "0l2fkndiyb3yglgrj7mlmlsgg6qjgjzbh4przqk999c8cfr6bc66";
        libraryHaskellDepends = [
          aeson array attoparsec base binary bytestring containers cryptonite
          data-default haskell-src-meta HDBC memory network old-locale
···
      }) {};
 
   "prettyprinter-ansi-terminal" = callPackage
-    ({ mkDerivation, ansi-terminal, base, doctest, prettyprinter, text
-     }:
-     mkDerivation {
-       pname = "prettyprinter-ansi-terminal";
-       version = "1.1.1.2";
-       sha256 = "0ha6vz707qzb5ky7kdsnw2zgphg2dnxrpbrxy8gaw119vwhb9q6k";
-       libraryHaskellDepends = [ ansi-terminal base prettyprinter text ];
-       testHaskellDepends = [ base doctest ];
-       description = "ANSI terminal backend for the »prettyprinter« package";
-       license = stdenv.lib.licenses.bsd2;
-     }) {};
-
-  "prettyprinter-ansi-terminal_1_1_2" = callPackage
     ({ mkDerivation, ansi-terminal, base, base-compat, containers
      , deepseq, doctest, gauge, prettyprinter, QuickCheck, text
      }:
···
        ];
        description = "ANSI terminal backend for the »prettyprinter« package";
        license = stdenv.lib.licenses.bsd2;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "prettyprinter-compat-annotated-wl-pprint" = callPackage
···
      }:
      mkDerivation {
        pname = "prettyprinter-convert-ansi-wl-pprint";
-       version = "1.1";
-       sha256 = "03565w1qvqgdr1g2nwj3d2xpqbx04xm45pjfkb9d6jb2fww2v65q";
-       revision = "1";
-       editedCabalFile = "1c4zcscmvq0vbdgnp7n0avv8si5jshl4kw2qd1lqmhr28kj8x45f";
-       libraryHaskellDepends = [
-         ansi-terminal ansi-wl-pprint base prettyprinter
-         prettyprinter-ansi-terminal text
-       ];
-       testHaskellDepends = [ base doctest ];
-       description = "Converter from »ansi-wl-pprint« documents to »prettyprinter«-based ones";
-       license = stdenv.lib.licenses.bsd2;
-     }) {};
-
-  "prettyprinter-convert-ansi-wl-pprint_1_1_1" = callPackage
-    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, doctest
-     , prettyprinter, prettyprinter-ansi-terminal, text
-     }:
-     mkDerivation {
-       pname = "prettyprinter-convert-ansi-wl-pprint";
        version = "1.1.1";
        sha256 = "0bgf2np1ymy6zsd1qacndgyipcf0bamw1wkkikaq57npbb7psc41";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base doctest ];
        description = "Converter from »ansi-wl-pprint« documents to »prettyprinter«-based ones";
        license = stdenv.lib.licenses.bsd2;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "prettyprinter-graphviz" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "product-profunctors_0_11_0_0" = callPackage
+    ({ mkDerivation, base, bifunctors, contravariant, criterion
+     , deepseq, profunctors, tagged, template-haskell
+     }:
+     mkDerivation {
+       pname = "product-profunctors";
+       version = "0.11.0.0";
+       sha256 = "1jx427xixykq9h353r7izd5nx1hpzc7g0hz4pcx6hnd0ql2d644a";
+       libraryHaskellDepends = [
+         base bifunctors contravariant profunctors tagged template-haskell
+       ];
+       testHaskellDepends = [ base profunctors ];
+       benchmarkHaskellDepends = [ base criterion deepseq ];
+       description = "product-profunctors";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "prof-flamegraph" = callPackage
     ({ mkDerivation, base, optparse-applicative }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "prometheus";
-       version = "2.2.1";
-       sha256 = "0wf7ayxxppdg1x1s2sjmlnnhdmlm18a90mgzg7wfvpmlb9kgvs3f";
+       version = "2.2.2";
+       sha256 = "11r3ckkv4fzgc5lgfvhgkngjvikzmapahh162grzdj6j47nm3hsf";
        libraryHaskellDepends = [
          atomic-primops base bytestring containers http-client
          http-client-tls http-types network-uri text transformers wai warp
···
      }:
      mkDerivation {
        pname = "provenience";
-       version = "0.1.0.1";
-       sha256 = "0z2lsyx59wk663y4p0xwl5sjrl1h3aqlqwig2xhvv9a1cf2bzzd3";
+       version = "0.1.0.2";
+       sha256 = "0wzja3vv21wgwxlmwcfc6vbkdr80jjkhxbxa41zz1i78j8cc3bri";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "quickcheck-instances_0_3_24" = callPackage
+    ({ mkDerivation, array, base, bytestring, case-insensitive
+     , containers, data-fix, hashable, integer-logarithms, old-time
+     , QuickCheck, scientific, splitmix, strict, tagged, text, these
+     , time, time-compat, transformers, transformers-compat
+     , unordered-containers, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "quickcheck-instances";
+       version = "0.3.24";
+       sha256 = "0jvb3d43hc1sa8aal1gjpwmrh65mswi72yssb98bj5hca4z8grk5";
+       libraryHaskellDepends = [
+         array base bytestring case-insensitive containers data-fix hashable
+         integer-logarithms old-time QuickCheck scientific splitmix strict
+         tagged text these time time-compat transformers transformers-compat
+         unordered-containers uuid-types vector
+       ];
+       testHaskellDepends = [
+         base containers QuickCheck tagged uuid-types
+       ];
+       benchmarkHaskellDepends = [ base bytestring QuickCheck ];
+       description = "Common quickcheck instances";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "quickcheck-io" = callPackage
     ({ mkDerivation, base, HUnit, QuickCheck }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "random-fu";
-       version = "0.2.7.6";
-       sha256 = "1as1g6i80jy3vnj71h33bj5ywlw9bsdcqwbl3pdqqfqp0mv13rfk";
+       version = "0.2.7.7";
+       sha256 = "1jk5qv7iddbqcyciih9vfylrwhbcabmy348waw5c7gchabxvqrl4";
        libraryHaskellDepends = [
          base erf math-functions monad-loops mtl random random-shuffle
          random-source rvar syb template-haskell transformers vector
···
      }:
      mkDerivation {
        pname = "random-source";
-       version = "0.3.0.10";
-       sha256 = "1ii7pr9dn6yfkkxsk504jmf6466phm15fhnk7894hhdg1qvfm43d";
+       version = "0.3.0.11";
+       sha256 = "0lwqbd0h495srgi2p8fsmsfk5hv5m3f6cxm12j61xx94fdyn98sv";
        libraryHaskellDepends = [
          base flexible-defaults mersenne-random-pure64 mtl mwc-random
          primitive random stateref syb template-haskell th-extras
···
      }:
      mkDerivation {
        pname = "rdf";
-       version = "0.1.0.3";
-       sha256 = "0bypvzr4xj3nvq839slhjcl6lzs4zp34yg6q3hdkwa5vgall6x2s";
-       revision = "1";
-       editedCabalFile = "0x5zdjbyrpap5qs40yl0m96fcgy11f6s5r3v0n8n5904cxa5sqy3";
-       libraryHaskellDepends = [
-         attoparsec base bytestring deepseq dlist fgl text transformers
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion deepseq text
-       ];
-       description = "Representation and Incremental Processing of RDF Data";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "rdf_0_1_0_4" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, criterion, deepseq
-     , dlist, fgl, text, transformers
-     }:
-     mkDerivation {
-       pname = "rdf";
        version = "0.1.0.4";
        sha256 = "1ncvh2rkxmy3k3scrpf7zyambvr94s5hq6n2yb4h7f5yx6xzr0wk";
        libraryHaskellDepends = [
···
        ];
        description = "Representation and Incremental Processing of RDF Data";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "rdf4h" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "reanimate-svg_0_10_0_0" = callPackage
+  "reanimate-svg_0_10_2_0" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, containers
      , double-conversion, hspec, JuicyPixels, lens, linear, mtl
      , scientific, svg-tree, text, transformers, vector, xml
      }:
      mkDerivation {
        pname = "reanimate-svg";
-       version = "0.10.0.0";
-       sha256 = "16m1829ashjwmsammqhxkifxpgwnhvxf84w36hqr3f0g0zmhfhai";
+       version = "0.10.2.0";
+       sha256 = "0czj7yii9h24823rl2jlf8pqc670azgbzhrkbizdr2bnrz6g981g";
        libraryHaskellDepends = [
          attoparsec base bytestring containers double-conversion JuicyPixels
          lens linear mtl scientific text transformers vector xml
···
      }:
      mkDerivation {
        pname = "refined";
-       version = "0.6";
-       sha256 = "0clfkdj7lj33yryan50a37b6h434in8rwa6n9cnv8lwzvk0mayy6";
+       version = "0.6.1";
+       sha256 = "124sqpcii62jh2n2vfskg9jc8ic4hhlwmwim40f6a0dmhdnsh8lx";
        libraryHaskellDepends = [
          aeson base bytestring deepseq exceptions mtl QuickCheck
          template-haskell text these-skinny
···
        pname = "reflex-basic-host";
        version = "0.2.0.1";
        sha256 = "1bax3rcrwi3447wd7apramw0f248ddksl8lrdjgrph26bbh8vc1i";
-       revision = "1";
-       editedCabalFile = "11bzd169wpdn57d7krgx9bw4x5qzskp9d5abdn74x6ipy34cj5ml";
+       revision = "2";
+       editedCabalFile = "0nqr2nxrq1xplcapr6yy8fx4x85qiqz609f7rzz656zah7cfm8dl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "rfc5051_0_2" = callPackage
+    ({ mkDerivation, base, containers, text }:
+     mkDerivation {
+       pname = "rfc5051";
+       version = "0.2";
+       sha256 = "0nri7js5ymywh2gi3li25wrkl1nf712qhbzw5hn46fib83qsq73k";
+       libraryHaskellDepends = [ base containers text ];
+       testHaskellDepends = [ base text ];
+       description = "Simple unicode collation as per RFC5051";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "rg" = callPackage
     ({ mkDerivation, array, base, fmt, possibly, tasty, tasty-hunit
      , text, unordered-containers, vector
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "rio_0_1_18_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, directory
+     , exceptions, filepath, hashable, hspec, microlens, microlens-mtl
+     , mtl, primitive, process, QuickCheck, text, time, typed-process
+     , unix, unliftio, unliftio-core, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "rio";
+       version = "0.1.18.0";
+       sha256 = "11f1cxa9c90d7hgqn9bl08l499n2dzdj31f9pw9acb1nrlx5hik8";
+       libraryHaskellDepends = [
+         base bytestring containers deepseq directory exceptions filepath
+         hashable microlens microlens-mtl mtl primitive process text time
+         typed-process unix unliftio unliftio-core unordered-containers
+         vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers deepseq directory exceptions filepath
+         hashable hspec microlens microlens-mtl mtl primitive process
+         QuickCheck text time typed-process unix unliftio unliftio-core
+         unordered-containers vector
+       ];
+       description = "A standard library for Haskell";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "rio-orphans" = callPackage
     ({ mkDerivation, base, exceptions, fast-logger, hspec
      , monad-control, monad-logger, resourcet, rio, transformers-base
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "rio-prettyprint_0_1_1_0" = callPackage
+    ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, array
+     , base, Cabal, colour, mtl, path, rio, text
+     }:
+     mkDerivation {
+       pname = "rio-prettyprint";
+       version = "0.1.1.0";
+       sha256 = "1h092l46pfm6k3n0vb6c67gb64kahzc97qv45rhvp0cq2y5bqykf";
+       libraryHaskellDepends = [
+         aeson annotated-wl-pprint ansi-terminal array base Cabal colour mtl
+         path rio text
+       ];
+       description = "Pretty-printing for RIO";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "riot" = callPackage
     ({ mkDerivation, base, containers, directory, haskell98, mtl
      , ncurses, old-locale, packedstring, process, unix
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "rpmbuild-order_0_4_0" = callPackage
+  "rpmbuild-order_0_4_2" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, case-insensitive
      , containers, directory, extra, fgl, filepath, hspec
-     , optparse-applicative, process, simple-cmd-args
+     , optparse-applicative, process, simple-cmd-args, unix
      }:
      mkDerivation {
        pname = "rpmbuild-order";
-       version = "0.4.0";
-       sha256 = "1whjid4nml07wyy9al9w63213qbd2iacwz8dsfv7a9b3vn31yd3k";
+       version = "0.4.2";
+       sha256 = "18ay3wga9s3whky49c8v0x7drpv1sf536p4n3h1549zd5w3vjms7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          base bytestring directory extra fgl optparse-applicative
          simple-cmd-args
        ];
-       testHaskellDepends = [ base hspec ];
+       testHaskellDepends = [ base extra hspec unix ];
        description = "Order RPM packages by dependencies";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
     ({ mkDerivation, base, bytestring, file-embed, process, yaml }:
      mkDerivation {
        pname = "runhs";
-       version = "1.0.0.3";
-       sha256 = "019aabgxfkan0l3i8wawya84wix3qmclsx0lsc8p6hvz5fjdlx21";
+       version = "1.0.0.4";
+       sha256 = "01czfphzp252y62vrx1pys74xga3m7b6q9pbd0f20y3m74q337xi";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "sampling";
-       version = "0.3.4";
-       sha256 = "1cwx64llg6x6dnsld6lx6bmb4cljz8abqp0d6vmh4wk11vzjsly0";
+       version = "0.3.5";
+       sha256 = "13xkq8p656xybbpvkxp42qkkgc1majp18w384ap7l4sbxrxif7kv";
        libraryHaskellDepends = [
          base containers foldl mwc-random primitive vector
        ];
···
        benchmarkHaskellDepends = [ base criterion tagsoup text ];
        description = "A high level web scraping library for Haskell";
        license = stdenv.lib.licenses.asl20;
+     }) {};
+
+  "scalpel-search" = callPackage
+    ({ mkDerivation, base, hspec, scalpel, scalpel-core, tagsoup, text
+     , uri
+     }:
+     mkDerivation {
+       pname = "scalpel-search";
+       version = "0.1.0.0";
+       sha256 = "0qq8q9z3s37wcc6iwygn2hfh72k5kak93vmsvl3wn0k04lrivg60";
+       libraryHaskellDepends = [ base scalpel-core tagsoup text uri ];
+       testHaskellDepends = [
+         base hspec scalpel scalpel-core tagsoup text uri
+       ];
+       description = "scalpel scrapers for search engines";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "scan" = callPackage
···
        pname = "serversession";
        version = "1.0.1";
        sha256 = "08j8v6a2018bmvwsb7crdg0ajak74jggb073pdpx9s0pf3cfzyrz";
+       revision = "1";
+       editedCabalFile = "0sxr4c7nk16n51y53qwwjnvgqjdqjm1ybaqkf0r8y91fac8x47b5";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring data-default hashable nonce
          path-pieces text time transformers unordered-containers
···
      }) {};
 
   "shakebook" = callPackage
-    ({ mkDerivation, aeson, aeson-with, base, binary-instances, comonad
-     , comonad-extras, doctemplates, feed, free, hashable-time
-     , http-conduit, ixset-typed, ixset-typed-conversions, lens
-     , lens-aeson, mustache, pandoc, pandoc-types, path-extensions, rio
-     , shake-plus, sitemap-gen, slick, split, tasty, tasty-golden
-     , text-time, within, zipper-extra
+    ({ mkDerivation, aeson, aeson-better-errors, aeson-with, base
+     , binary, binary-instances, comonad, comonad-extras
+     , composite-aeson, composite-base, doctemplates, feed, free
+     , hashable-time, http-conduit, ixset-typed, ixset-typed-conversions
+     , lens, lens-aeson, lucid, lucid-cdn, mtl, mustache, pandoc
+     , pandoc-types, path, path-extensions, rio, shake-plus
+     , shake-plus-extended, sitemap-gen, slick, split, tasty
+     , tasty-golden, text-time, vinyl, zipper-extra
      }:
      mkDerivation {
        pname = "shakebook";
-       version = "0.9.1.0";
-       sha256 = "14b94gmy95whypmgqwbqr0kp5nrnk8s87dih35s85zsbmi2q1pzm";
+       version = "0.11.0.0";
+       sha256 = "0h6pq3y7ll5l83a682mwk60zipsm91w0srgrigdgi7l4wdhn7qzb";
        libraryHaskellDepends = [
-         aeson aeson-with base binary-instances comonad comonad-extras
-         doctemplates feed free hashable-time http-conduit ixset-typed
-         ixset-typed-conversions lens lens-aeson mustache pandoc
-         pandoc-types path-extensions rio shake-plus sitemap-gen slick split
-         text-time within zipper-extra
+         aeson aeson-better-errors aeson-with base binary binary-instances
+         comonad comonad-extras composite-aeson composite-base doctemplates
+         feed free hashable-time http-conduit ixset-typed
+         ixset-typed-conversions lens lens-aeson lucid lucid-cdn mtl
+         mustache pandoc pandoc-types path path-extensions rio shake-plus
+         shake-plus-extended sitemap-gen slick split text-time vinyl
+         zipper-extra
        ];
        testHaskellDepends = [
-         aeson aeson-with base binary-instances comonad comonad-extras
-         doctemplates feed free hashable-time http-conduit ixset-typed
-         ixset-typed-conversions lens lens-aeson mustache pandoc
-         pandoc-types path-extensions rio shake-plus sitemap-gen slick split
-         tasty tasty-golden text-time within zipper-extra
+         aeson aeson-better-errors aeson-with base binary binary-instances
+         comonad comonad-extras composite-aeson composite-base doctemplates
+         feed free hashable-time http-conduit ixset-typed
+         ixset-typed-conversions lens lens-aeson lucid lucid-cdn mtl
+         mustache pandoc pandoc-types path path-extensions rio shake-plus
+         shake-plus-extended sitemap-gen slick split tasty tasty-golden
+         text-time vinyl zipper-extra
        ];
        description = "Shake-based technical documentation generator; HTML & PDF";
        license = stdenv.lib.licenses.mit;
···
      }) {};
 
   "slynx" = callPackage
-    ({ mkDerivation, async, base, bytestring, containers, elynx-markov
-     , elynx-seq, elynx-tools, elynx-tree, hmatrix, megaparsec
-     , monad-logger, mwc-random, optparse-applicative, scientific, text
+    ({ mkDerivation, async, attoparsec, base, bytestring, containers
+     , elynx-markov, elynx-seq, elynx-tools, elynx-tree, hmatrix
+     , monad-logger, mwc-random, optparse-applicative, text
      , transformers, vector
      }:
      mkDerivation {
        pname = "slynx";
-       version = "0.3.0";
-       sha256 = "18nncc771b16ngkihza9skx1n73w811sg1p2hphp5pl7vkbl4wkr";
+       version = "0.3.1";
+       sha256 = "0af18y25lix0sy3vyl56d9a8yrvn9riw3vw2azwcq9pzia460qki";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         async base bytestring containers elynx-markov elynx-seq elynx-tools
-         elynx-tree hmatrix megaparsec monad-logger mwc-random
-         optparse-applicative scientific text transformers vector
+         async attoparsec base bytestring containers elynx-markov elynx-seq
+         elynx-tools elynx-tree hmatrix monad-logger mwc-random
+         optparse-applicative text transformers vector
        ];
-       executableHaskellDepends = [ base elynx-seq elynx-tools ];
+       executableHaskellDepends = [ base ];
        description = "Handle molecular sequences";
        license = stdenv.lib.licenses.gpl3Plus;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "splitmix_0_1" = callPackage
+  "splitmix_0_1_0_1" = callPackage
     ({ mkDerivation, async, base, base-compat, base-compat-batteries
      , bytestring, clock, containers, criterion, deepseq, HUnit
      , math-functions, process, random, test-framework
···
      }:
      mkDerivation {
        pname = "splitmix";
-       version = "0.1";
-       sha256 = "1yhbh6zsklz5fbas2v69xd2qi3xvk4zidzl0acv17fyxa9rwh48w";
+       version = "0.1.0.1";
+       sha256 = "0ahr3zxx0n9pjxpldrphqx5rhanar6alq3km7qvszipa8r46jjsd";
        libraryHaskellDepends = [ base deepseq time ];
        testHaskellDepends = [
          async base base-compat base-compat-batteries bytestring containers
···
      }:
      mkDerivation {
        pname = "stack";
-       version = "2.3.1";
-       sha256 = "1l17jdkr6ca3hwm4v8bshq2zbadqhb35hk2gfjy2dri1mdibcsdr";
+       version = "2.3.3";
+       sha256 = "1j2z8cgb9c56g39dh5ff2sri3r3vxddy6ymznkywn6d7c1z4j7qs";
        configureFlags = [
          "-fdisable-git-info" "-fhide-dependency-versions"
          "-fsupported-build"
···
     ({ mkDerivation, array, async, base, base-orphans
      , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector
      , clock, containers, contravariant, criterion, cryptohash, deepseq
-     , directory, fail, filepath, free, ghc-prim, hashable, hspec
+     , directory, filepath, free, ghc-prim, hashable, hspec
      , hspec-smallcheck, integer-gmp, lifted-base, monad-control
-     , mono-traversable, network, primitive, resourcet, safe, semigroups
-     , smallcheck, store-core, syb, template-haskell, text, th-lift
+     , mono-traversable, network, primitive, resourcet, safe, smallcheck
+     , store-core, syb, template-haskell, text, th-lift
      , th-lift-instances, th-orphans, th-reify-many, th-utilities, time
      , transformers, unordered-containers, vector
      , vector-binary-instances, void, weigh
      }:
      mkDerivation {
        pname = "store";
-       version = "0.7.4";
-       sha256 = "1lipkzhdr6m5555r2p3s5g5i2am9kg34dznfakcsxv5z20vzd31z";
+       version = "0.7.6";
+       sha256 = "1gzax38chn57ybikvddk6g8msyv52y5s30yndpp64bdh3kqwlchq";
        libraryHaskellDepends = [
          array async base base-orphans base64-bytestring bifunctors
          bytestring containers contravariant cryptohash deepseq directory
-         fail filepath free ghc-prim hashable hspec hspec-smallcheck
-         integer-gmp lifted-base monad-control mono-traversable network
-         primitive resourcet safe semigroups smallcheck store-core syb
-         template-haskell text th-lift th-lift-instances th-orphans
-         th-reify-many th-utilities time transformers unordered-containers
-         vector void
+         filepath free ghc-prim hashable hspec hspec-smallcheck integer-gmp
+         lifted-base monad-control mono-traversable network primitive
+         resourcet safe smallcheck store-core syb template-haskell text
+         th-lift th-lift-instances th-orphans th-reify-many th-utilities
+         time transformers unordered-containers vector void
        ];
        testHaskellDepends = [
          array async base base-orphans base64-bytestring bifunctors
          bytestring clock containers contravariant cryptohash deepseq
-         directory fail filepath free ghc-prim hashable hspec
-         hspec-smallcheck integer-gmp lifted-base monad-control
-         mono-traversable network primitive resourcet safe semigroups
-         smallcheck store-core syb template-haskell text th-lift
-         th-lift-instances th-orphans th-reify-many th-utilities time
-         transformers unordered-containers vector void
+         directory filepath free ghc-prim hashable hspec hspec-smallcheck
+         integer-gmp lifted-base monad-control mono-traversable network
+         primitive resourcet safe smallcheck store-core syb template-haskell
+         text th-lift th-lift-instances th-orphans th-reify-many
+         th-utilities time transformers unordered-containers vector void
        ];
        benchmarkHaskellDepends = [
          array async base base-orphans base64-bytestring bifunctors
          bytestring cereal cereal-vector containers contravariant criterion
-         cryptohash deepseq directory fail filepath free ghc-prim hashable
-         hspec hspec-smallcheck integer-gmp lifted-base monad-control
-         mono-traversable network primitive resourcet safe semigroups
-         smallcheck store-core syb template-haskell text th-lift
-         th-lift-instances th-orphans th-reify-many th-utilities time
-         transformers unordered-containers vector vector-binary-instances
-         void weigh
+         cryptohash deepseq directory filepath free ghc-prim hashable hspec
+         hspec-smallcheck integer-gmp lifted-base monad-control
+         mono-traversable network primitive resourcet safe smallcheck
+         store-core syb template-haskell text th-lift th-lift-instances
+         th-orphans th-reify-many th-utilities time transformers
+         unordered-containers vector vector-binary-instances void weigh
        ];
        description = "Fast binary serialization";
        license = stdenv.lib.licenses.mit;
      }) {};
 
   "store-core" = callPackage
-    ({ mkDerivation, base, bytestring, fail, ghc-prim, primitive, text
+    ({ mkDerivation, base, bytestring, ghc-prim, primitive, text
      , transformers
      }:
      mkDerivation {
        pname = "store-core";
-       version = "0.4.4.2";
-       sha256 = "184f3whh7kzc2fkm1mgllg06f002z8shayz1b8cvhal3qg1qahf9";
+       version = "0.4.4.3";
+       sha256 = "1b0fpv8wdp9lcvqplls548xrh336cb1m617fzd0ysbzqhhg5r3fv";
        libraryHaskellDepends = [
-         base bytestring fail ghc-prim primitive text transformers
+         base bytestring ghc-prim primitive text transformers
        ];
        description = "Fast and lightweight binary serialization";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "store-streaming";
-       version = "0.2.0.0";
-       sha256 = "0fhcv0lvmhdc53fx9y2dvvykvap7dz4asnajy95kpwhaz6z1xc2k";
+       version = "0.2.0.2";
+       sha256 = "1hnzpyw5l90nrm3vlrwbv8517iaaq0razfjj6m8a41jy2lkgf4gz";
        libraryHaskellDepends = [
          async base bytestring conduit free resourcet store store-core
          streaming-commons text transformers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "stratosphere_0_56_0" = callPackage
+  "stratosphere_0_57_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
      , hashable, hspec, hspec-discover, lens, template-haskell, text
      , unordered-containers
      }:
      mkDerivation {
        pname = "stratosphere";
-       version = "0.56.0";
-       sha256 = "00pszcypf0ckagxx2l5ldl0m6kacr3xbmw0yxfcjh6hs34543v8n";
+       version = "0.57.0";
+       sha256 = "1ksxy117bizi4bnj7skv5hq7rsw2gz0w5yg5b3xhc6ialkq9in4z";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "strict_0_4" = callPackage
+    ({ mkDerivation, assoc, base, binary, bytestring, deepseq, ghc-prim
+     , hashable, text, these, transformers
+     }:
+     mkDerivation {
+       pname = "strict";
+       version = "0.4";
+       sha256 = "0gs5fqsrwsc3y5w6fp91p9frgh7h42kd9smyg04cw284d5wfx7r7";
+       libraryHaskellDepends = [
+         assoc base binary bytestring deepseq ghc-prim hashable text these
+         transformers
+       ];
+       description = "Strict data types and String IO";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "strict-base" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "strict-lens" = callPackage
+    ({ mkDerivation, base, lens, strict }:
+     mkDerivation {
+       pname = "strict-lens";
+       version = "0.4";
+       sha256 = "16sqk7kvg8322f0aflnsb7v76p1c1xfvn3h0hxgvmkb5ll1ak92y";
+       libraryHaskellDepends = [ base lens strict ];
+       description = "Lenses for types in strict package";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "strict-list" = callPackage
     ({ mkDerivation, base, hashable, QuickCheck, quickcheck-instances
      , rerebase, semigroupoids, tasty, tasty-hunit, tasty-quickcheck
···
        ];
        description = "Strict linked list";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "strict-optics" = callPackage
+    ({ mkDerivation, base, optics-core, strict }:
+     mkDerivation {
+       pname = "strict-optics";
+       version = "0.4";
+       sha256 = "1xy5yziq37h37irbg3win7risxc46s143iqqh95lqv08fybk5b09";
+       libraryHaskellDepends = [ base optics-core strict ];
+       description = "Optics for types in strict package";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "strict-tuple" = callPackage
···
        pname = "string-interpolate";
        version = "0.3.0.0";
        sha256 = "0h7lqr5g11pr9ikzg7j26fgj9m8659j1vpcwggvndv6k71sh281a";
+       revision = "1";
+       editedCabalFile = "0id31zpxvmgs63acy3lx8myms5i8w70cfr1dx5yryzy5l66vaq0w";
        libraryHaskellDepends = [
          base bytestring haskell-src-exts haskell-src-meta split
          template-haskell text text-conversions utf8-string
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "stylish-haskell_0_11_0_3" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
+     , directory, file-embed, filepath, haskell-src-exts, HsYAML
+     , HsYAML-aeson, HUnit, mtl, optparse-applicative, random
+     , semigroups, strict, syb, test-framework, test-framework-hunit
+     , text
+     }:
+     mkDerivation {
+       pname = "stylish-haskell";
+       version = "0.11.0.3";
+       sha256 = "10svl5q95n9i76rqvlxibi784qzvdyg8qfl1xwk7c32y84nyfibn";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring Cabal containers directory file-embed
+         filepath haskell-src-exts HsYAML HsYAML-aeson mtl semigroups syb
+         text
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring Cabal containers directory file-embed
+         filepath haskell-src-exts HsYAML HsYAML-aeson mtl
+         optparse-applicative strict syb
+       ];
+       testHaskellDepends = [
+         aeson base bytestring Cabal containers directory file-embed
+         filepath haskell-src-exts HsYAML HsYAML-aeson HUnit mtl random syb
+         test-framework test-framework-hunit text
+       ];
+       description = "Haskell code prettifier";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "stylist" = callPackage
     ({ mkDerivation, async, base, css-syntax, hashable, hspec
      , network-uri, QuickCheck, scientific, text, unordered-containers
···
      }:
      mkDerivation {
        pname = "sweet-egison";
-       version = "0.1.0.3";
-       sha256 = "17xqkhlxqkmn1ayhsxl1pw3y4fqxbq4lcdaq9ispp57qd3dcvd7v";
+       version = "0.1.1.0";
+       sha256 = "1zd1l2gbg7dp53d4jzki6k8jqxdvqgy5gl6jdy325hx1fycrixql";
        libraryHaskellDepends = [
          backtracking base egison-pattern-src egison-pattern-src-th-mode
          haskell-src-exts haskell-src-meta logict template-haskell
···
        broken = true;
      }) {};
 
+  "tasty-bdd" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, base, exceptions, free, HUnit
+     , microlens, microlens-th, mtl, pretty, pretty-show
+     , qm-interpolated-string, regex-posix, tagged, tasty
+     , tasty-expected-failure, tasty-fail-fast, tasty-hunit, temporary
+     , text, transformers, tree-diff
+     }:
+     mkDerivation {
+       pname = "tasty-bdd";
+       version = "0.1.0.1";
+       sha256 = "1da1983hampnkkm6kwxp8w1bkhzic27qbnkckkmsziaz8kbkhcpi";
+       libraryHaskellDepends = [
+         base exceptions free HUnit microlens microlens-th mtl pretty
+         pretty-show tagged tasty tasty-fail-fast tasty-hunit temporary text
+         transformers tree-diff
+       ];
+       testHaskellDepends = [
+         aeson aeson-qq base exceptions HUnit mtl qm-interpolated-string
+         regex-posix tasty tasty-expected-failure tasty-fail-fast
+         tasty-hunit temporary text transformers
+       ];
+       description = "BDD tests language and tasty provider";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "tasty-dejafu" = callPackage
     ({ mkDerivation, base, dejafu, random, tagged, tasty }:
      mkDerivation {
···
        pname = "tasty-hedgehog";
        version = "1.0.0.2";
        sha256 = "1vsv3m6brhshpqm8qixz97m7h0nx67cj6ira4cngbk7mf5rqylv5";
-       revision = "3";
-       editedCabalFile = "0vjr63nsc3z2jzc80clx2pzhcx1l53bqscwflvwwgjy0gmsshakd";
+       revision = "4";
+       editedCabalFile = "0z47ssv9030px81sxivhw5jp7yfpr6r6anlf03slks31jkzvx4gl";
        libraryHaskellDepends = [ base hedgehog tagged tasty ];
        testHaskellDepends = [
          base hedgehog tasty tasty-expected-failure
···
        broken = true;
      }) {};
 
+  "testcontainers" = callPackage
+    ({ mkDerivation, aeson, aeson-optics, base, bytestring, exceptions
+     , hspec, hspec-discover, mtl, network, optics-core, process
+     , resourcet, tasty, tasty-discover, tasty-hspec, tasty-hunit, text
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "testcontainers";
+       version = "0.2.0.0";
+       sha256 = "0drdi2qqgiw499lwvkdc5yn8x7mys6l4p47jcz0af62fczpa5dnh";
+       libraryHaskellDepends = [
+         aeson aeson-optics base bytestring exceptions mtl network
+         optics-core process resourcet tasty text unliftio-core
+       ];
+       testHaskellDepends = [
+         base hspec tasty tasty-discover tasty-hspec tasty-hunit text
+       ];
+       testToolDepends = [ hspec-discover tasty-discover ];
+       description = "Docker containers for your integration tests";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "testing-feat" = callPackage
     ({ mkDerivation, base, QuickCheck, size-based
      , testing-type-modifiers
···
      }) {};
 
   "thread-hierarchy" = callPackage
-    ({ mkDerivation, base, containers, hspec, stm }:
-     mkDerivation {
-       pname = "thread-hierarchy";
-       version = "0.3.0.1";
-       sha256 = "0d2wbm75f59vj1h18afdhb1wqyclv5gpgj6pyrhbcnf7aa2490c1";
-       libraryHaskellDepends = [ base containers stm ];
-       testHaskellDepends = [ base containers hspec stm ];
-       description = "Simple Haskel thread management in hierarchical manner";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "thread-hierarchy_0_3_0_2" = callPackage
     ({ mkDerivation, base, containers, hspec, hspec-discover, stm }:
      mkDerivation {
        pname = "thread-hierarchy";
···
        testToolDepends = [ hspec-discover ];
        description = "Simple Haskell thread management in hierarchical manner";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "thread-local-storage" = callPackage
···
 
   "thread-supervisor" = callPackage
     ({ mkDerivation, base, clock, containers, data-default, hspec
-     , QuickCheck, unliftio
-     }:
-     mkDerivation {
-       pname = "thread-supervisor";
-       version = "0.1.0.0";
-       sha256 = "1gn2h4c84fdhppwjzkj9sr2rggc5q7193lf1n8c6ggzz6k2cj2rs";
-       libraryHaskellDepends = [
-         base clock containers data-default unliftio
-       ];
-       testHaskellDepends = [
-         base clock data-default hspec QuickCheck unliftio
-       ];
-       description = "A simplified implementation of Erlang/OTP like supervisor over thread";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "thread-supervisor_0_1_0_1" = callPackage
-    ({ mkDerivation, base, clock, containers, data-default, hspec
      , hspec-discover, QuickCheck, unliftio
      }:
      mkDerivation {
···
        testToolDepends = [ hspec-discover ];
        description = "A simplified implementation of Erlang/OTP like supervisor over thread";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "threadPool" = callPackage
···
        broken = true;
      }) {};
 
-  "tldr_0_7_0" = callPackage
+  "tldr_0_7_1" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, cmark, containers
      , directory, filepath, optparse-applicative, semigroups, tasty
      , tasty-golden, text, typed-process
      }:
      mkDerivation {
        pname = "tldr";
-       version = "0.7.0";
-       sha256 = "1y0lw65k9kjmqk27hsq3gr40af4jnwksf739ihp2dg4llyrqgvhl";
+       version = "0.7.1";
+       sha256 = "1vc9rxyxczs7kswrjq2c4lziwvnwri53ng8yq4724hpjvybiqs57";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "tlynx" = callPackage
-    ({ mkDerivation, aeson, array, base, bytestring, comonad
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad
      , containers, elynx-tools, elynx-tree, gnuplot, lifted-async
-     , megaparsec, monad-logger, mwc-random, optparse-applicative
-     , parallel, primitive, scientific, statistics, text, transformers
-     , vector
+     , monad-logger, mwc-random, optparse-applicative, parallel
+     , statistics, text, transformers, vector
      }:
      mkDerivation {
        pname = "tlynx";
-       version = "0.3.0";
-       sha256 = "070r7j87s3206a5hpkhlfszpnpc7ngil88r6iq2752kijjik2x6v";
+       version = "0.3.1";
+       sha256 = "172mbc79r14sccyghnbvcsa95lypas2gvqn1rf80f9yi2rsz9amy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson array base bytestring comonad containers elynx-tools
-         elynx-tree gnuplot lifted-async megaparsec monad-logger mwc-random
-         optparse-applicative parallel primitive scientific statistics text
-         transformers vector
+         aeson attoparsec base bytestring comonad containers elynx-tools
+         elynx-tree gnuplot lifted-async monad-logger mwc-random
+         optparse-applicative parallel statistics text transformers vector
        ];
-       executableHaskellDepends = [ base elynx-tools ];
+       executableHaskellDepends = [ base ];
        description = "Handle phylogenetic trees";
        license = stdenv.lib.licenses.gpl3Plus;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "unordered-containers_0_2_11_0" = callPackage
+  "unordered-containers_0_2_12_0" = callPackage
     ({ mkDerivation, base, bytestring, ChasingBottoms, containers
-     , deepseq, deepseq-generics, gauge, hashable, hashmap, HUnit, mtl
-     , QuickCheck, random, test-framework, test-framework-hunit
-     , test-framework-quickcheck2
+     , deepseq, gauge, hashable, hashmap, HUnit, mtl, QuickCheck, random
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "unordered-containers";
-       version = "0.2.11.0";
-       sha256 = "0z58qi781n1znjw35s1pq0k7fqn0995jqmrsznp1773gg66qqfib";
+       version = "0.2.12.0";
+       sha256 = "085x73b2cfab85nkbwmcvc5i6v8kbnpbiv35gnmgw44zlm7an7a8";
        libraryHaskellDepends = [ base deepseq hashable ];
        testHaskellDepends = [
          base ChasingBottoms containers hashable HUnit QuickCheck random
          test-framework test-framework-hunit test-framework-quickcheck2
        ];
        benchmarkHaskellDepends = [
-         base bytestring containers deepseq deepseq-generics gauge hashable
-         hashmap mtl random
+         base bytestring containers deepseq gauge hashable hashmap mtl
+         random
        ];
        description = "Efficient hashing-based container types";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "uuid-bytes" = callPackage
-    ({ mkDerivation, base, byteslice, bytesmith, HUnit
-     , natural-arithmetic, primitive, small-bytearray-builder, tasty
-     , tasty-hunit, wide-word
+    ({ mkDerivation, base, bytebuild, byteslice, bytesmith, HUnit
+     , natural-arithmetic, primitive, tasty, tasty-hunit, wide-word
      }:
      mkDerivation {
        pname = "uuid-bytes";
-       version = "0.1.1.0";
-       sha256 = "13kskg9j847w3f01pf0r24kf1nnfz5srfp268ip5n55ji26h5cmr";
+       version = "0.1.2.0";
+       sha256 = "08sfxj0900pgpbvasi2n2x93qwglir2ijc43fpn5xf0gq7z2b25r";
        libraryHaskellDepends = [
-         base byteslice bytesmith natural-arithmetic primitive
-         small-bytearray-builder wide-word
+         base bytebuild byteslice bytesmith natural-arithmetic primitive
+         wide-word
        ];
        testHaskellDepends = [
          base byteslice HUnit natural-arithmetic primitive tasty tasty-hunit
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.6.2";
-       sha256 = "05lp2jwc4m432k1k9x8305a5a4m92lnxab4341lpmqc3vy30hz7a";
+       version = "3.6.3";
+       sha256 = "0w0887xrkai5xhky245gnjjfq7d8cw43l90rmfvhqxwdf7jkkxc8";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        librarySystemDepends = [ vulkan ];
        description = "Bindings to the Vulkan graphics API";
···
 
   "web-rep" = callPackage
     ({ mkDerivation, attoparsec, base, box, box-socket, clay
-     , concurrency, doctest, foldl, generic-lens
-     , interpolatedstring-perl6, language-javascript, lens, lucid, mtl
-     , numhask, optparse-generic, scotty, tasty, tasty-hspec, text
-     , transformers, unordered-containers, wai-middleware-static
-     , wai-websockets, websockets
+     , concurrency, doctest, generic-lens, interpolatedstring-perl6
+     , language-javascript, lens, lucid, mtl, numhask, optparse-generic
+     , scotty, tasty, tasty-hspec, text, transformers
+     , unordered-containers, wai-middleware-static, wai-websockets
+     , websockets
      }:
      mkDerivation {
        pname = "web-rep";
-       version = "0.6.0";
-       sha256 = "1ljlmfcjhiiqmsw2zfvxifr13g35c0mj33rkdxih6yz948czz17m";
+       version = "0.7.0";
+       sha256 = "1045b19rjs1hgw92kq8z6wzm7jmx8k73ad9z4m2vzv1jwjhbgin4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         attoparsec base box box-socket clay concurrency foldl generic-lens
+         attoparsec base box box-socket clay concurrency generic-lens
          interpolatedstring-perl6 language-javascript lens lucid mtl numhask
          scotty text transformers unordered-containers wai-middleware-static
          wai-websockets websockets
···
 
   "webex-teams-api" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, bitset-word8
-     , bytestring, conduit, data-default, hspec, http-conduit
-     , http-types, network-uri, optparse-applicative, text, utf8-string
-     , wai, warp
-     }:
-     mkDerivation {
-       pname = "webex-teams-api";
-       version = "0.2.0.0";
-       sha256 = "02x4g10r0rl1g4fbqkj8zxcbz64g8dck4d77f0gswkadsn5y6mkp";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson attoparsec base bitset-word8 bytestring conduit data-default
-         http-conduit network-uri text
-       ];
-       executableHaskellDepends = [
-         aeson base bytestring data-default http-conduit
-         optparse-applicative text utf8-string
-       ];
-       testHaskellDepends = [
-         aeson async attoparsec base bytestring data-default hspec
-         http-conduit http-types network-uri text wai warp
-       ];
-       description = "A Haskell bindings for Webex Teams API";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "webex-teams-api_0_2_0_1" = callPackage
-    ({ mkDerivation, aeson, async, attoparsec, base, bitset-word8
      , bytestring, conduit, data-default, hspec, hspec-discover
      , http-conduit, http-types, network-uri, optparse-applicative, text
      , utf8-string, wai, warp
···
        testToolDepends = [ hspec-discover ];
        description = "A Haskell bindings for Webex Teams API";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "webex-teams-conduit" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, conduit
-     , data-default, hspec, http-client, http-conduit, http-types
-     , network-uri, optparse-applicative, text, utf8-string, wai, warp
-     , webex-teams-api
-     }:
-     mkDerivation {
-       pname = "webex-teams-conduit";
-       version = "0.2.0.0";
-       sha256 = "0p9ffj3qm84c7m4w5bfpn53vcs96p7gdlyk87mjmc9h9i6v7sz0d";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base conduit webex-teams-api ];
-       executableHaskellDepends = [
-         base bytestring conduit data-default http-client
-         optparse-applicative text utf8-string webex-teams-api
-       ];
-       testHaskellDepends = [
-         aeson async base bytestring conduit data-default hspec http-conduit
-         http-types network-uri text wai warp webex-teams-api
-       ];
-       description = "Conduit wrapper of Webex Teams List API";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "webex-teams-conduit_0_2_0_1" = callPackage
-    ({ mkDerivation, aeson, async, base, bytestring, conduit
      , data-default, hspec, hspec-discover, http-client, http-conduit
      , http-types, network-uri, optparse-applicative, text, utf8-string
      , wai, warp, webex-teams-api
···
        testToolDepends = [ hspec-discover ];
        description = "Conduit wrapper of Webex Teams List API";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "webex-teams-pipes" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, data-default
-     , hspec, http-client, http-conduit, http-types, network-uri
-     , optparse-applicative, pipes, text, utf8-string, wai, warp
-     , webex-teams-api
-     }:
-     mkDerivation {
-       pname = "webex-teams-pipes";
-       version = "0.2.0.0";
-       sha256 = "001ilf2yj6q8rqcagjlh28rad191jyjjr1cpk6cf84v66isdbykp";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base pipes webex-teams-api ];
-       executableHaskellDepends = [
-         base bytestring data-default http-client optparse-applicative pipes
-         text utf8-string webex-teams-api
-       ];
-       testHaskellDepends = [
-         aeson async base bytestring data-default hspec http-conduit
-         http-types network-uri pipes text wai warp webex-teams-api
-       ];
-       description = "Pipes wrapper of Webex Teams List API";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "webex-teams-pipes_0_2_0_1" = callPackage
-    ({ mkDerivation, aeson, async, base, bytestring, data-default
      , hspec, hspec-discover, http-client, http-conduit, http-types
      , network-uri, optparse-applicative, pipes, text, utf8-string, wai
      , warp, webex-teams-api
···
        testToolDepends = [ hspec-discover ];
        description = "Pipes wrapper of Webex Teams List API";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "webfinger-client" = callPackage
···
        broken = true;
      }) {};
 
+  "xlsx_0_8_1" = callPackage
+    ({ mkDerivation, attoparsec, base, base64-bytestring, binary-search
+     , bytestring, conduit, containers, criterion, data-default, deepseq
+     , Diff, errors, extra, filepath, groom, lens, mtl, network-uri
+     , old-locale, raw-strings-qq, safe, smallcheck, tasty, tasty-hunit
+     , tasty-smallcheck, text, time, transformers, vector, xeno
+     , xml-conduit, zip-archive, zlib
+     }:
+     mkDerivation {
+       pname = "xlsx";
+       version = "0.8.1";
+       sha256 = "1prb6369af2w0rni2ha32yzd9r17yi0xnyn1dzwdzq03maxikgy9";
+       libraryHaskellDepends = [
+         attoparsec base base64-bytestring binary-search bytestring conduit
+         containers data-default deepseq errors extra filepath lens mtl
+         network-uri old-locale safe text time transformers vector xeno
+         xml-conduit zip-archive zlib
+       ];
+       testHaskellDepends = [
+         base bytestring containers Diff groom lens mtl raw-strings-qq
+         smallcheck tasty tasty-hunit tasty-smallcheck text time vector
+         xml-conduit
+       ];
+       benchmarkHaskellDepends = [ base bytestring criterion ];
+       description = "Simple and incomplete Excel file parser/writer";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "xlsx-tabular" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, data-default
      , lens, text, xlsx
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "yesod-bin_1_6_0_6" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, conduit, conduit-extra
+     , containers, data-default-class, directory, file-embed, filepath
+     , fsnotify, http-client, http-client-tls, http-reverse-proxy
+     , http-types, network, optparse-applicative, process
+     , project-template, say, split, stm, streaming-commons, tar, text
+     , time, transformers, transformers-compat, unliftio
+     , unordered-containers, wai, wai-extra, warp, warp-tls, yaml, zlib
+     }:
+     mkDerivation {
+       pname = "yesod-bin";
+       version = "1.6.0.6";
+       sha256 = "044xk75pymw6limz08zicxp4lw8jqf6f2ilj8i2qw2h419w3ry9f";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base bytestring Cabal conduit conduit-extra containers
+         data-default-class directory file-embed filepath fsnotify
+         http-client http-client-tls http-reverse-proxy http-types network
+         optparse-applicative process project-template say split stm
+         streaming-commons tar text time transformers transformers-compat
+         unliftio unordered-containers wai wai-extra warp warp-tls yaml zlib
+       ];
+       description = "The yesod helper executable";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "yesod-bootstrap" = callPackage
     ({ mkDerivation, base, blaze-html, blaze-markup, bootstrap-types
      , shakespeare, text, transformers, yesod-core, yesod-elements
···
      }:
      mkDerivation {
        pname = "zeolite-lang";
-       version = "0.7.1.0";
-       sha256 = "1sdnnixy3n54nhr4kq3xa066nplgz19c03iwjvaahj2a0iir07m4";
+       version = "0.8.0.0";
+       sha256 = "1ahr69w65hd70jc0jrc3dfz1gnjqxlg9w24djzm6826wskg31fa9";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {inherit (pkgs) zlib;};
 
+  "zlib_0_6_2_2" = callPackage
+    ({ mkDerivation, base, bytestring, QuickCheck, tasty, tasty-hunit
+     , tasty-quickcheck, zlib
+     }:
+     mkDerivation {
+       pname = "zlib";
+       version = "0.6.2.2";
+       sha256 = "1fii0qfc60lfp93vwb78p2fv3jjyklgdhw4ms262z6cysq6qkd84";
+       libraryHaskellDepends = [ base bytestring ];
+       librarySystemDepends = [ zlib ];
+       testHaskellDepends = [
+         base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck
+       ];
+       description = "Compression and decompression in the gzip and zlib formats";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs) zlib;};
+
   "zlib-bindings" = callPackage
     ({ mkDerivation, base, bytestring, hspec, QuickCheck, zlib }:
      mkDerivation {
···
   "zre" = callPackage
     ({ mkDerivation, async, attoparsec, base, binary, bytestring
      , cereal, containers, data-default, directory, filepath
-     , lifted-async, monad-control, mtl, network, network-bsd
-     , network-info, network-multicast, optparse-applicative, process
-     , QuickCheck, quickcheck-instances, random, repline, sockaddr, stm
-     , text, time, transformers-base, uuid, zeromq4-haskell
+     , lifted-async, lifted-base, monad-control, mtl, network
+     , network-bsd, network-info, network-multicast
+     , optparse-applicative, process, QuickCheck, quickcheck-instances
+     , random, repline, sockaddr, stm, text, time, transformers-base
+     , uuid, zeromq4-haskell
      }:
      mkDerivation {
        pname = "zre";
-       version = "0.1.3.0";
-       sha256 = "09wsfghrba6akhxwl19khln0w64p919glz14f6sdijiagmkd87zw";
+       version = "0.1.4.0";
+       sha256 = "1877q8qshp88sghnys6a52c6sjc9qxxg062j473fjyv0vc4cpy4d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          async attoparsec base binary bytestring cereal containers
-         data-default directory filepath lifted-async monad-control mtl
-         network network-bsd network-info network-multicast
-         optparse-applicative process random sockaddr stm text time
-         transformers-base uuid zeromq4-haskell
+         data-default directory filepath lifted-async lifted-base
+         monad-control mtl network network-bsd network-info
+         network-multicast optparse-applicative process random sockaddr stm
+         text time transformers-base uuid zeromq4-haskell
        ];
        executableHaskellDepends = [
          async base bytestring lifted-async monad-control mtl

pkgs/top-level/haskell-packages.nix

···
     "ghcjs"
     "ghcjs86"
     "integer-simple"
+    "native-bignum"
+    "ghcHEAD"
+  ];
+
+  nativeBignumIncludes = [
+    "ghcHEAD"
   ];
 
   haskellLib = import ../development/haskell-modules/lib.nix {
···
     in pkgs.recurseIntoAttrs (pkgs.lib.genAttrs
       integerSimpleGhcNames
       (name: compiler.${name}.override { enableIntegerSimple = true; }));
+
+    # Starting from GHC 9, integer-{simple,gmp} is replaced by ghc-bignum
+    # with "native" and "gmp" backends.
+    native-bignum = let
+      nativeBignumGhcNames = pkgs.lib.filter
+        (name: builtins.elem name nativeBignumIncludes)
+        (pkgs.lib.attrNames compiler);
+    in pkgs.recurseIntoAttrs (pkgs.lib.genAttrs
+      nativeBignumGhcNames
+      (name: compiler.${name}.override { enableNativeBignum = true; }));
   };
 
   # Default overrides that are applied to all package sets.
···
       };
     });
 
+    native-bignum = let
+      nativeBignumGhcNames = pkgs.lib.filter
+        (name: builtins.elem name nativeBignumIncludes)
+        (pkgs.lib.attrNames compiler);
+    in pkgs.lib.genAttrs nativeBignumGhcNames (name: packages.${name}.override {
+      ghc = bh.compiler.native-bignum.${name};
+      buildHaskellPackages = bh.packages.native-bignum.${name};
+      overrides = _self : _super : {
+        integer-gmp = null;
+      };
+    });
   };
 }