Merge pull request #171099 from NixOS/haskell-updates

haskellPackages: update stackage and hackage

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "762464dcc5ce93f1c6a9a746feb6bd1bd0c47006",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/762464dcc5ce93f1c6a9a746feb6bd1bd0c47006.tar.gz",
-  "sha256": "0k1qp34lsc08a99p669v8n0fxs6mdzwc2bz87v0hdah4qagi4z4g",
-  "msg": "Update from Hackage at 2022-04-20T23:34:08Z"
+  "commit": "08ae12813ead00810e00ffe9dae284fcafe6a08a",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/08ae12813ead00810e00ffe9dae284fcafe6a08a.tar.gz",
+  "sha256": "00jc08pifnp791s1scscdhgwlf75v9682a7vjis1djnhj3y5s3ny",
+  "msg": "Update from Hackage at 2022-05-01T06:09:30Z"
 }

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

···
   hls-class-plugin = dontCheck super.hls-class-plugin;
   hls-selection-range-plugin = dontCheck super.hls-selection-range-plugin;
 
-  # Similar RTS issue in test suite:
-  # rts/linker/elf_reloc_aarch64.c:98: encodeAddendAarch64: Assertion `isInt64(21+12, addend)' failed.
-  hls-hlint-plugin = dontCheck super.hls-hlint-plugin;
-  hls-ormolu-plugin = dontCheck super.hls-ormolu-plugin;
-  hls-haddock-comments-plugin = dontCheck super.hls-haddock-comments-plugin;
-
-
   # https://github.com/ekmett/half/issues/35
   half = dontCheck super.half;
 
   # We disable profiling on aarch64, so tests naturally fail
   ghc-prof = dontCheck super.ghc-prof;
 
+} // lib.optionalAttrs (pkgs.stdenv.hostPlatform.isAarch64 && builtins.compareVersions super.ghc.version "9.2" < 0) {
+  # Some aarch64 issues have been fixed since 9.2
+
+  # Similar RTS issue in test suite:
+  # rts/linker/elf_reloc_aarch64.c:98: encodeAddendAarch64: Assertion `isInt64(21+12, addend)' failed.
+  # Fixed since 9.2
+  hls-ormolu-plugin = dontCheck super.hls-ormolu-plugin;
+  hls-haddock-comments-plugin = dontCheck super.hls-haddock-comments-plugin;
+  hls-rename-plugin = dontCheck super.hls-rename-plugin;
+  hls-fourmolu-plugin = dontCheck super.hls-fourmolu-plugin;
 } // lib.optionalAttrs pkgs.stdenv.hostPlatform.isAarch32 {
   # AARCH32-SPECIFIC OVERRIDES
 

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

···
 
   lsp = assert super.lsp.version == "1.4.0.0"; dontCheck super.lsp;
 
-  hls-test-utils = assert super.hls-test-utils.version == "1.2.0.0"; appendPatches [
-    (fetchpatch {
-      url = "https://github.com/haskell/haskell-language-server/commit/074593987e9086e308b89ecde336de2c64861dc0.patch";
-      sha256 = "sha256-uTlIbGQKulP3963UPL2V9cqMoIvPscK+s2W/HtBmMWc=";
-      relative = "hls-test-utils";
-    })
-    (fetchpatch {
-      url = "https://github.com/haskell/haskell-language-server/commit/78305f21783807b04baebca4860c255bfe84d4ab.patch";
-      sha256 = "sha256-oe8Q8kBJBkel+pR5imFj43NVpm4afcyLgAUCWhrIoPk=";
-      relative = "hls-test-utils";
-    })
-   ] super.hls-test-utils;
-
   # 2021-05-08: Tests fail: https://github.com/haskell/haskell-language-server/issues/1809
   hls-eval-plugin = dontCheck super.hls-eval-plugin;
 
···
   # 2021-09-18: https://github.com/haskell/haskell-language-server/issues/2205
   hls-stylish-haskell-plugin = doJailbreak super.hls-stylish-haskell-plugin;
 
+  # Necesssary .txt files are not included in sdist.
+  # https://github.com/haskell/haskell-language-server/pull/2887
+  hls-change-type-signature-plugin = dontCheck super.hls-change-type-signature-plugin;
+
   # Too strict bounds on hspec
   # https://github.com/haskell-works/hw-hspec-hedgehog/issues/62
   # https://github.com/haskell-works/hw-prim/issues/132
···
     url = "https://github.com/erebe/wstunnel/pull/107/commits/47c1f62bdec1dbe77088d9e3ceb6d872f922ce34.patch";
     sha256 = "sha256-fW5bVbAGQxU/gd9zqgVNclwKraBtUjkKDek7L0c4+O0=";
   }) super.wstunnel;
+
+  # Adjustment of bounds on servant is unreleased
+  # https://github.com/haskell-servant/servant-cassava/commit/66617547851d38d48f5f1d1b786db1286bdafa9d
+  servant-cassava = assert super.servant-cassava.version == "0.10.1";
+    doJailbreak super.servant-cassava;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   hls-haddock-comments-plugin = dontCheck super.hls-haddock-comments-plugin;
   hls-floskell-plugin = dontCheck super.hls-floskell-plugin;
   hls-call-hierarchy-plugin = dontCheck super.hls-call-hierarchy-plugin;
+  # 2022-05-05: Tests fail and I have no way to debug them.
+  hls-rename-plugin = dontCheck super.hls-rename-plugin;
 
   # We are lacking pure pgrep at the moment for tests to work
   tmp-postgres = dontCheck super.tmp-postgres;
···
   # tests appear to be failing to link or something:
   # https://hydra.nixos.org/build/174540882/nixlog/9
   regex-rure = dontCheck super.regex-rure;
+  # same
+  # https://hydra.nixos.org/build/174540882/nixlog/9
+  jacinda = dontCheck super.jacinda;
 })

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

···
   time = null;
   transformers = null;
   unix = null;
-  xhtml = null;
+  # GHC only bundles the xhtml library if haddock is enabled, check if this is
+  # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
+  xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;
 
   # cabal-install needs more recent versions of Cabal and base16-bytestring.
   cabal-install = super.cabal-install.overrideScope (self: super: {

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

···
   time = null;
   transformers = null;
   unix = null;
-  xhtml = null;
+  # GHC only bundles the xhtml library if haddock is enabled, check if this is
+  # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
+  xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;
 
   # Needs Cabal 3.0.x.
   cabal-install = super.cabal-install.overrideScope (self: super: { Cabal = self.Cabal_3_2_1_0; });

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

···
   time = null;
   transformers = null;
   unix = null;
-  xhtml = null;
+  # GHC only bundles the xhtml library if haddock is enabled, check if this is
+  # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
+  xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;
 
   # GHC 8.8.x can build haddock version 2.23.*
   haddock = self.haddock_2_23_1;

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

···
   time = null;
   transformers = null;
   unix = null;
-  xhtml = null;
+  # GHC only bundles the xhtml library if haddock is enabled, check if this is
+  # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
+  xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;
 
   # cabal-install needs more recent versions of Cabal and base16-bytestring.
   cabal-install = (doJailbreak super.cabal-install).overrideScope (self: super: {

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

···
   time = null;
   transformers = null;
   unix = null;
-  xhtml = null;
+  # GHC only bundles the xhtml library if haddock is enabled, check if this is
+  # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
+  xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;
 
   # Tests fail because of typechecking changes
   conduit = dontCheck super.conduit;
···
     # causing the build-depends to be skipped. Since the dependency
     # list hasn't changed much since 0.6.4, we can just reuse the
     # normal expression.
-    inherit (self.ghc-exactprint_1_4_1) src version;
+    inherit (self.ghc-exactprint_1_5_0) src version;
     revision = null; editedCabalFile = null;
     libraryHaskellDepends = [
       self.fail
···
   } super.memory);
 
   # Use hlint from git for GHC 9.2.1 support
-  hlint = doDistribute (
-    overrideSrc {
-      version = "unstable-2021-12-12";
-      src = pkgs.fetchFromGitHub {
-        owner = "ndmitchell";
-        repo = "hlint";
-        rev = "77a9702e10b772a7695c08682cd4f450fd0e9e46";
-        sha256 = "0hpp3iw7m7w2abr8vb86gdz3x6c8lj119zxln933k90ia7bmk8jc";
-      };
-    } super.hlint
-  );
+  hlint = self.hlint_3_4;
 
   # https://github.com/sjakobi/bsb-http-chunked/issues/38
   bsb-http-chunked = dontCheck super.bsb-http-chunked;
···
   some = doJailbreak super.some;
   fourmolu = super.fourmolu_0_6_0_0;
   # hls-fourmolu-plugin in this version has a to strict upper bound of fourmolu <= 0.5.0.0
-  hls-fourmolu-plugin = assert super.hls-fourmolu-plugin.version == "1.0.2.0"; doJailbreak super.hls-fourmolu-plugin;
+  hls-fourmolu-plugin = assert super.hls-fourmolu-plugin.version == "1.0.3.0"; doJailbreak super.hls-fourmolu-plugin;
   implicit-hie-cradle = doJailbreak super.implicit-hie-cradle;
   # 1.3 introduced support for GHC 9.2.x, so when this assert fails, the jailbreak can be removed
   hashtables = assert super.hashtables.version == "1.2.4.2"; doJailbreak super.hashtables;
···
   # Compare: https://haskell-language-server.readthedocs.io/en/latest/supported-versions.html
   haskell-language-server = overrideCabal (old: {libraryHaskellDepends = builtins.filter (x: x != super.hls-tactics-plugin) old.libraryHaskellDepends;})
     (appendConfigureFlags [
-    "-f-alternateNumberFormat"
-    "-f-class"
-    "-f-eval"
     "-f-haddockComments"
-    "-f-hlint"
     "-f-retrie"
     "-f-splice"
     "-f-tactics"
   ] (super.haskell-language-server.override {
-    hls-alternate-number-format-plugin = null;
-    hls-class-plugin = null;
-    hls-eval-plugin = null;
     hls-haddock-comments-plugin = null;
     hls-hlint-plugin = null;
     hls-retrie-plugin = null;

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

···
   time = null;
   transformers = null;
   unix = null;
-  xhtml = null;
+  # GHC only bundles the xhtml library if haddock is enabled, check if this is
+  # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
+  xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;
 
   # https://github.com/tibbe/unordered-containers/issues/214
   unordered-containers = dontCheck super.unordered-containers;

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

···
   - bower-json
   - bowntz
   - bpath
+  - BPS
   - braid
   - brain-bleep
   - Bravo
···
   - bytestring-substring
   - bytestring-time
   - bytestring-typenats
+  - bzlib-conduit-jappie
   - c10k
   - c2ats
   - cab
···
   - cabal-constraints
   - cabal-db
   - cabal-dependency-licenses
+  - cabal-detailed-quickcheck
   - cabal-dev
   - cabal-dir
   - cabal-edit
···
   - CoreDump
   - CoreErlang
   - core-haskell
+  - core-webserver-warp
   - Coroutine
   - coroutine-object
   - CouchDB
···
   - ede
   - edenmodules
   - edis
+  - EdisonAPI
   - EdisonCore
   - edit
   - edit-lenses
···
   - hdo
   - hdph-closure
   - hdr-histogram
+  - HDRUtils
   - headergen
   - heap-console
   - heapsort
···
   - polysemy-mocks
   - polysemy-readline
   - polysemy-req
+  - polysemy-scoped-fs
   - polysemy-zoo
   - polytypeable
   - polyvariadic
···
   - Referees
   - references
   - refined-http-api-data
+  - refined-with
   - reflection-extras
   - reflex-basic-host
   - reflex-dom-ace
···
   - servant-auth-hmac
   - servant-avro
   - servant-benchmark
-  - servant-cassava
   - servant-client-js
   - servant-db
   - servant-dhall
···
   - typalyze
   - typeable-mock
   - typeable-th
+  - typecheck-plugin-nat-simple
   - type-combinators
   - typed-digits
   - typed-encoding
···
   - utf8-prelude
   - utf8-validator
   - UTFTConverter
+  - util
   - util-logict
   - util-plus
   - util-primitive
···
   - Zwaluw
   - zxcvbn-hs
   - zydiskell
+  - zyre2

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

···
   - brick == 0.64.*                     # 2021-12-03: matterhorn depends on brick < 0.65
   - path == 0.9.0                       # 2021-12-03: path version building with stackage genvalidity and GHC 9.0.2
   - ormolu == 0.2.*                     # 2022-02-21: For ghc 8.8 and 8.10
-  - ghc-exactprint == 1.4.*             # 2022-02-07: preserve for now, 1.5.0 has a breaking change without type changes
   - ShellCheck == 0.7.2                 # 2022-02-20: haskell-ci 0.14 needs this
   - weeder == 2.2.*                     # 2022-02-21: preserve for GHC 8.10.7
   - attoparsec == 0.13.*                # 2022-02-23: Needed to compile elm for now

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

···
-# Stackage LTS 19.4
+# Stackage LTS 19.5
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - array-memoize ==0.6.0
   - arrow-extras ==0.1.0.1
   - arrows ==0.4.4.2
-  - ascii ==1.1.2.0
+  - ascii ==1.1.3.0
   - ascii-case ==1.0.0.10
   - ascii-char ==1.0.0.14
   - asciidiagram ==1.3.3.3
···
   - ascii-numbers ==1.0.0.0
   - ascii-predicates ==1.0.0.10
   - ascii-progress ==0.3.3.0
-  - ascii-superset ==1.0.1.12
+  - ascii-superset ==1.0.1.13
   - ascii-th ==1.0.0.10
   - asn1-encoding ==0.9.6
   - asn1-parse ==0.9.5
···
   - cast ==0.1.0.2
   - caster ==0.0.3.0
   - cayley-client ==0.4.17
-  - cborg ==0.2.6.0
-  - cborg-json ==0.2.3.0
+  - cborg ==0.2.7.0
+  - cborg-json ==0.2.4.0
   - cdar-mBound ==0.1.0.4
   - c-enum ==0.1.1.3
   - cereal ==0.5.8.2
···
   - dual ==0.1.1.1
   - dual-tree ==0.2.3.0
   - dublincore-xml-conduit ==0.1.0.2
-  - dunai ==0.8.1
+  - dunai ==0.8.2
   - duration ==0.2.0.0
   - dvorak ==0.1.0.0
   - dynamic-state ==0.3.1
···
   - ghc-check ==0.5.0.6
   - ghc-compact ==0.1.0.0
   - ghc-core ==0.5.6
-  - ghc-events ==0.17.0.2
+  - ghc-events ==0.17.0.3
   - ghc-exactprint ==0.6.4
   - ghcid ==0.8.7
   - ghci-hexcalc ==0.1.1.0
···
   - HandsomeSoup ==0.4.2
   - handwriting ==0.1.0.3
   - happstack-server ==7.7.2
-  - happstack-server-tls ==7.2.1.1
+  - happstack-server-tls ==7.2.1.2
   - happy ==1.20.0
   - happy-meta ==0.2.0.11
   - HasBigDecimal ==0.1.1
···
   - hasql-optparse-applicative ==0.3.0.8
   - hasql-pool ==0.5.2.2
   - hasql-queue ==1.2.0.2
-  - hasql-th ==0.4.0.11
+  - hasql-th ==0.4.0.12
   - hasql-transaction ==1.0.1.1
   - has-transformers ==0.1.0.4
   - hasty-hamiltonian ==1.3.4
···
   - hw-json-simd ==0.1.1.1
   - hw-json-simple-cursor ==0.1.1.1
   - hw-json-standard-cursor ==0.2.3.2
+  - hwk ==0.6
   - hw-kafka-client ==4.0.3
   - hw-mquery ==0.2.1.1
   - hworker ==0.1.0.1
···
   - hxt-unicode ==9.0.2.4
   - hybrid-vectors ==0.2.2
   - hyper ==0.2.1.1
-  - hyperloglog ==0.4.5
+  - hyperloglog ==0.4.6
   - hyphenation ==0.8.2
   - iconv ==0.4.1.3
   - identicon ==0.2.2
···
   - pattern-arrows ==0.0.2
   - pava ==0.1.1.3
   - pcg-random ==0.1.3.7
-  - pcre2 ==2.1.0.1
+  - pcre2 ==2.1.1
   - pcre-heavy ==1.0.0.2
   - pcre-light ==0.4.1.0
   - pcre-utils ==0.1.8.2
···
   - ref-fd ==0.5
   - refined ==0.6.3
   - reflection ==2.1.6
-  - reform ==0.2.7.4
-  - reform-blaze ==0.2.4.3
+  - reform ==0.2.7.5
+  - reform-blaze ==0.2.4.4
   - reform-hamlet ==0.0.5.3
-  - reform-happstack ==0.2.5.4
+  - reform-happstack ==0.2.5.5
   - RefSerialize ==0.4.0
   - ref-tf ==0.5.0.1
   - regex ==1.1.0.1
···
   - sdl2 ==2.5.3.0
   - sdl2-ttf ==2.1.2
   - search-algorithms ==0.3.2
-  - secp256k1-haskell ==0.6.0
+  - secp256k1-haskell ==0.6.1
   - securemem ==0.1.10
   - selda ==0.5.1.0
   - selda-sqlite ==0.1.7.1
···
   - sequence-formats ==1.6.6.1
   - sequenceTools ==1.5.2
   - serf ==0.1.1.0
-  - serialise ==0.2.4.0
+  - serialise ==0.2.5.0
   - servant ==0.19
   - servant-auth ==0.4.1.0
   - servant-auth-client ==0.4.1.0
···
   - singletons-presburger ==0.6.1.0
   - singletons-th ==3.0
   - siphash ==1.0.3
+  - Sit ==0.2022.3.18
   - sitemap-gen ==0.1.0.0
   - sized ==1.0.0.0
   - skein ==1.0.9.4
···
   - SVGFonts ==1.8.0.1
   - svg-tree ==0.6.2.4
   - swagger2 ==2.8.2
-  - swish ==0.10.1.0
+  - swish ==0.10.2.0
   - syb ==0.7.2.1
   - sydtest-discover ==0.0.0.1
   - symbol ==0.2.4
···
   - wai-cors ==0.2.7
   - wai-enforce-https ==1.0.0.0
   - wai-eventsource ==3.0.0
-  - wai-extra ==3.1.8
+  - wai-extra ==3.1.10
   - wai-feature-flags ==0.1.0.3
   - wai-handler-launch ==3.0.3.1
   - wai-logger ==2.4.0
···
   - webgear-server ==1.0.1
   - webpage ==0.0.5.1
   - web-plugins ==0.4.1
-  - web-routes ==0.27.14.3
-  - web-routes-boomerang ==0.28.4.2
-  - web-routes-happstack ==0.23.12.1
-  - web-routes-hsp ==0.24.6.1
-  - web-routes-wai ==0.24.3.1
+  - web-routes ==0.27.14.4
+  - web-routes-boomerang ==0.28.4.3
+  - web-routes-happstack ==0.23.12.2
+  - web-routes-hsp ==0.24.6.2
+  - web-routes-wai ==0.24.3.2
   - webrtc-vad ==0.1.0.3
   - websockets ==0.12.7.3
   - websockets-simple ==0.2.0
···
   - yesod-auth-hashdb ==1.7.1.7
   - yesod-auth-oauth2 ==0.7.0.1
   - yesod-bin ==1.6.2.1
-  - yesod-core ==1.6.22.0
+  - yesod-core ==1.6.23
   - yesod-eventsource ==1.6.0.1
   - yesod-form ==1.7.0
   - yesod-form-bootstrap4 ==3.0.1
···
   - yesod-routes-flow ==3.0.0.2
   - yesod-sitemap ==1.6.0
   - yesod-static ==1.6.1.0
-  - yesod-test ==1.6.12
+  - yesod-test ==1.6.13
   - yesod-websockets ==0.3.0.3
   - yes-precure5-command ==5.5.3
   - yi-rope ==0.11

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

···
  - adp-multi-monadiccp
  - aeson-native
  - aeson-result
+ - affine
  - afv
  - agda-server
  - agda-snippets-hakyll
  - agentx
  - aip
  - aivika-distributed
+ - alg
  - algebra-checkers
  - algebra-driven-design
  - algebra-sql
···
  - apiary-websockets
  - apis
  - apotiki
+ - appendful-persistent
  - approx-rand-test
  - arbor-monad-metric-datadog
  - archive-tar-bytestring
···
  - ascii
  - ascii-cows
  - ascii-table
- - ascii_1_2_0_0
+ - ascii_1_2_2_0
  - asic
  - asif
  - assert4hs-hspec
···
  - berp
  - bff
  - bglib
+ - bifunctor
  - billboard-parser
  - billeksah-forms
  - billeksah-main
···
  - bindings-ppdev
  - bindynamic
  - binembed-example
+ - binrep
  - bioace
  - bioalign
  - biofasta
···
  - bytelog
  - bytestring-builder-varword
  - bytestring-read
+ - ca
  - cabal-bounds
  - cabal-cache
  - cabal-cargs
···
  - cassy
  - casui
  - categorical-algebra
+ - category
  - category-extras
  - cautious-gen
  - cctools-workqueue
···
  - configifier
  - configurator-ng
  - conic-graphs
+ - constraint
  - constraint-manip
+ - constraint-reflection
  - constructible
  - consumers
  - container
···
  - copilot-libraries
  - copilot-sbv
  - copilot-theorem
+ - core-webserver-servant
  - coroutine-enumerator
  - coroutine-iteratee
  - couch-simple
···
  - exinst-deepseq
  - exinst-hashable
  - exinst-serialise
+ - exist
+ - exist-instances
  - expand
  - expat-enumerator
  - expiring-containers
···
  - extract-dependencies
  - factual-api
  - fadno
+ - fair
  - fallingblocks
  - family-tree
  - fast-arithmetic
···
  - fluent-logger
  - fluent-logger-conduit
  - fmt-for-rio
+ - foldable1
  - follower
  - foo
  - formal
···
  - geniconvert
  - geniserver
  - genvalidity-aeson
+ - genvalidity-appendful
  - genvalidity-hspec-aeson
  - genvalidity-mergeful
  - genvalidity-mergeless
···
  - iteratee-parsec
  - iteratee-stm
  - iterio-server
+ - ival
  - ivor
  - ivory-avr-atmega328p-registers
  - ivory-backend-c
···
  - ivory-serialize
  - ivory-stdlib
  - ivy-web
+ - ix
  - ixset
  - ixset-typed-binary-instance
  - ixset-typed-cassava
···
  - keid-sound-openal
  - keid-ui-dearimgui
  - kevin
+ - key-vault
  - keyring
  - keysafe
  - keystore
···
  - phonetic-languages-simplified-base
  - phonetic-languages-simplified-common
  - phonetic-languages-simplified-examples-array
- - phonetic-languages-simplified-examples-common
  - phonetic-languages-simplified-generalized-examples-array
  - phonetic-languages-simplified-generalized-examples-common
  - phonetic-languages-simplified-generalized-properties-array
···
  - process-streaming
  - procrastinating-structure
  - producer
+ - product
  - product-isomorphic
  - prof2dot
  - profiterole
···
  - raketka
  - rallod
  - random-access-file
+ - random-class
  - random-effin
  - random-hypergeometric
  - range-space
+ - ranged-list
  - rasa
  - rasa-example-config
  - rasa-ext-bufs
···
  - roundtrip-xml
  - route-generator
  - route-planning
+ - row
  - rpc
  - rpf
  - rsagl
···
  - smcdel
  - smith-cli
  - smith-client
+ - smt
  - smtlib2-debug
  - smtlib2-pipe
  - smtlib2-quickcheck
···
  - twitter-conduit
  - twitter-enumerator
  - twitter-types-lens
+ - txt
  - type-assertions
  - type-cache
  - type-cereal
···
  - uniqueness-periods-vector-filters
  - uniqueness-periods-vector-general
  - uniqueness-periods-vector-properties
+ - universal
  - universe
  - universe-dependent-sum
  - universe-th
···
  - vacuum-graphviz
  - vacuum-opengl
  - vacuum-ubigraph
+ - valid
  - variable-precision
  - vault-tool-server
  - vault-trans

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

···
        license = lib.licenses.gpl2Only;
      }) {};
 
+  "BPS" = callPackage
+    ({ mkDerivation, base, extra, free, mtl, resourcet, STMonadTrans
+     , symbol, template-haskell, TLT, transformers
+     }:
+     mkDerivation {
+       pname = "BPS";
+       version = "0.1.0.0";
+       sha256 = "0rkrjj42p9ybcifmsmz8717yyf2q3vzwm4y42khxz824vdxa9q2j";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base extra free mtl resourcet STMonadTrans symbol template-haskell
+         transformers
+       ];
+       executableHaskellDepends = [
+         base extra free mtl resourcet STMonadTrans symbol template-haskell
+         transformers
+       ];
+       testHaskellDepends = [
+         base extra free mtl resourcet STMonadTrans symbol template-haskell
+         TLT transformers
+       ];
+       description = "Translations of classic Truth Maintenance Systems";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "Baggins" = callPackage
     ({ mkDerivation, base, cairo, containers, mtl }:
      mkDerivation {
···
        pname = "EdisonAPI";
        version = "1.3.1";
        sha256 = "0vmmlsj8ggbpwx6fkf5fvb6jp0zpx6iba6b28m80lllr2p8bi8wm";
+       revision = "1";
+       editedCabalFile = "1nlw49ifjvav102pigksi46xg0zwnpfj29j3db0rr76hykikpipy";
        libraryHaskellDepends = [ base mtl ];
        description = "A library of efficient, purely-functional data structures (API)";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "EdisonCore" = callPackage
···
        platforms = [
          "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
        ];
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) pfstools;};
 
   "HERA" = callPackage
···
      }:
      mkDerivation {
        pname = "TLT";
-       version = "0.1.0.0";
-       sha256 = "125hfd8ig706zsizyn959qsjcadsgbiqq3dnygjxambvd2d135pr";
+       version = "0.1.0.1";
+       sha256 = "1b91ax19dfgi50rlkfvjjywzz6w998d5jsq5c0yz620rcdl7jrki";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "aeson-helper" = callPackage
-    ({ mkDerivation, aeson, base, text, unordered-containers, vector }:
+    ({ mkDerivation, aeson, base, text, vector }:
      mkDerivation {
        pname = "aeson-helper";
-       version = "0.1.0.0";
-       sha256 = "0s4gq827i2wyflcaxbhlr8f8svlw8szzmwax9d7vnxk9wy9fw8w0";
-       libraryHaskellDepends = [
-         aeson base text unordered-containers vector
-       ];
+       version = "0.2.0.0";
+       sha256 = "1im4grk23vkxgpa1fhhdg0ghg5j1z2qcwqvnpjk1s168993j2522";
+       libraryHaskellDepends = [ aeson base text vector ];
        description = "Aeson helper func";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
     ({ mkDerivation, aeson, aeson-helper, base, text }:
      mkDerivation {
        pname = "aeson-result";
-       version = "0.1.0.0";
-       sha256 = "10bnzh7vlh42sip0z7mvx5jxrsi7p2s3vqy55pfg2pb17czzly2y";
+       version = "0.2.0.0";
+       sha256 = "1sssh9k4fkmsn96m796f5j3p5a5sc8khqgjfj4pzi1r935368n1f";
        libraryHaskellDepends = [ aeson aeson-helper base text ];
        description = "API Result for aeson";
        license = lib.licenses.bsd3;
···
        libraryHaskellDepends = [ alg base ];
        description = "Affine spaces (generalized)";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "affine-invariant-ensemble-mcmc" = callPackage
···
      }) {};
 
   "alfred-margaret" = callPackage
-    ({ mkDerivation, aeson, base, containers, deepseq, hashable, hspec
-     , hspec-expectations, primitive, QuickCheck, quickcheck-instances
-     , text, unordered-containers, vector
+    ({ mkDerivation, aeson, base, bytestring, containers, criterion
+     , deepseq, hashable, hspec, hspec-expectations, primitive
+     , QuickCheck, quickcheck-instances, text, unordered-containers
+     , vector
      }:
      mkDerivation {
        pname = "alfred-margaret";
-       version = "1.1.1.0";
-       sha256 = "1z3plc2a6qnlx1cpb3icw44h3lbspaq2n7djl4pljhb4dm5bflbq";
+       version = "1.1.2.0";
+       sha256 = "02p9djplw187v4k7mi6mh6mjjs7gir0crghyxfkjqjrxk5s7f3j7";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
-         aeson base containers deepseq hashable primitive text
+         aeson base bytestring containers deepseq hashable primitive text
          unordered-containers vector
        ];
+       executableHaskellDepends = [ base ];
        testHaskellDepends = [
-         base deepseq hspec hspec-expectations QuickCheck
+         base deepseq hspec hspec-expectations primitive QuickCheck
          quickcheck-instances text
        ];
+       benchmarkHaskellDepends = [ base criterion deepseq vector ];
        description = "Fast Aho-Corasick string searching";
        license = lib.licenses.bsd3;
      }) {};
···
        pname = "alg";
        version = "0.2.13.1";
        sha256 = "0764j2njb86qdskck3nvbrh61v99hqdhf8aj9irblm6smdlrv4l3";
-       revision = "1";
-       editedCabalFile = "0rm66k502d8la140ffawd38yaf0hr92h8x7xrq6krn6ypljwql0v";
+       revision = "2";
+       editedCabalFile = "1ffcn0ahv2jl6191baik5sqsh5mb61n1g4rgkiybd1mspgsmnnwy";
        libraryHaskellDepends = [ base dual util ];
        description = "Algebraic structures";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "alga" = callPackage
···
      }:
      mkDerivation {
        pname = "annotated-exception";
-       version = "0.2.0.1";
-       sha256 = "0lqr283ql82kfpd6rvznwj4p0h4176mg9xnb1wnzdxxbl9rn3xgl";
+       version = "0.2.0.2";
+       sha256 = "07njn6r1c3n1nblnlz5q2jrk5887vxxr2yzw4khqwayy0nmgbc7l";
        libraryHaskellDepends = [
          base containers safe-exceptions text unliftio-core
        ];
···
        libraryHaskellDepends = [ base colour ];
        description = "Simple ANSI terminal support, with Windows compatibility";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "ansi-terminal_0_11_3" = callPackage
+    ({ mkDerivation, base, colour }:
+     mkDerivation {
+       pname = "ansi-terminal";
+       version = "0.11.3";
+       sha256 = "0swy5alj4xvfsnjrfiwxdlgzdnggjy6lgbfwph2d7c8zyzn67mgl";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base colour ];
+       description = "Simple ANSI terminal support, with Windows compatibility";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ansi-terminal-game" = callPackage
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "appendful" = callPackage
+    ({ mkDerivation, aeson, base, containers, deepseq, mtl, validity
+     , validity-containers
+     }:
+     mkDerivation {
+       pname = "appendful";
+       version = "0.0.0.0";
+       sha256 = "1wb2abnr2k7d7bgvh3zjyg55s1236cgnz1idldpxcrib30nr01l8";
+       libraryHaskellDepends = [
+         aeson base containers deepseq mtl validity validity-containers
+       ];
+       license = lib.licenses.mit;
+     }) {};
+
+  "appendful-persistent" = callPackage
+    ({ mkDerivation, appendful, base, containers, genvalidity
+     , genvalidity-appendful, genvalidity-hspec, genvalidity-persistent
+     , hspec, microlens, monad-logger, mtl, path, path-io, persistent
+     , persistent-sqlite, persistent-template, QuickCheck, text
+     , validity
+     }:
+     mkDerivation {
+       pname = "appendful-persistent";
+       version = "0.0.0.0";
+       sha256 = "0h0hdjkkrz8ckhs8r8n0vm983513lahi9bd89i1hyqlycrckbphl";
+       libraryHaskellDepends = [
+         appendful base containers microlens persistent
+       ];
+       testHaskellDepends = [
+         appendful base containers genvalidity genvalidity-appendful
+         genvalidity-hspec genvalidity-persistent hspec monad-logger mtl
+         path path-io persistent persistent-sqlite persistent-template
+         QuickCheck text validity
+       ];
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "appendmap" = callPackage
···
      }:
      mkDerivation {
        pname = "ascii";
-       version = "1.1.2.0";
-       sha256 = "17yh71i28m1m4hnlbd6sp234kwqpgsdpn4bmv2g283vq37mkn09n";
+       version = "1.1.3.0";
+       sha256 = "0pzyamd64mj8sx5a43gi7yjdy5dx6k9648ihbgsri8k8srlhm0c8";
+       revision = "1";
+       editedCabalFile = "0lxjb940qm86i1b2i9dgyj8874y49spwmkm5ninxd5hs7g9manll";
        libraryHaskellDepends = [
          ascii-case ascii-char ascii-group ascii-numbers ascii-predicates
          ascii-superset ascii-th base bytestring text
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ascii_1_2_0_0" = callPackage
+  "ascii_1_2_2_0" = callPackage
     ({ mkDerivation, ascii-case, ascii-char, ascii-group, ascii-numbers
      , ascii-predicates, ascii-superset, ascii-th, base, bytestring
      , hedgehog, text
      }:
      mkDerivation {
        pname = "ascii";
-       version = "1.2.0.0";
-       sha256 = "1m043s6030mwz4gam83nb1dyxsbkaar6i7cdvzjfgawv9gdpwkbb";
+       version = "1.2.2.0";
+       sha256 = "1s6xm2b0g1jcbg8xfkhysmk4rhsx2342dd980md827rnfc5l4w80";
        libraryHaskellDepends = [
          ascii-case ascii-char ascii-group ascii-numbers ascii-predicates
          ascii-superset ascii-th base bytestring text
···
      }:
      mkDerivation {
        pname = "ascii-superset";
-       version = "1.0.1.12";
-       sha256 = "04kp4v0m1z1sh78862qryhkq1a5jzv1hdkyyrsv2m7caqkh8rn2c";
-       libraryHaskellDepends = [
-         ascii-char base bytestring hashable text
-       ];
-       testHaskellDepends = [ ascii-char base hedgehog text ];
-       description = "Representing ASCII with refined supersets";
-       license = lib.licenses.asl20;
-     }) {};
-
-  "ascii-superset_1_0_1_13" = callPackage
-    ({ mkDerivation, ascii-char, base, bytestring, hashable, hedgehog
-     , text
-     }:
-     mkDerivation {
-       pname = "ascii-superset";
        version = "1.0.1.13";
        sha256 = "0pf1awrx0bfpgyc96r1ycybgpy801iqxr8qf3vp9pvbnfava1v8s";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ ascii-char base hedgehog text ];
        description = "Representing ASCII with refined supersets";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ascii-table" = callPackage
···
      , http-types, language-bash, megaparsec, network-uri
      , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
      , rio, scheduler, stm, tasty, tasty-hunit, text, time, transformers
-     , typed-process, versions
+     , typed-process, unix, versions
      }:
      mkDerivation {
        pname = "aura";
-       version = "3.2.7";
-       sha256 = "07ya2vd94grh6fs7k5kq25yh95xfk5mdqcgqq84anjz0phprq5z3";
-       revision = "1";
-       editedCabalFile = "16z28nkj5ladbbrg2h5sc1qcl3335g3i37x02h0by8bpqbkld6xr";
+       version = "3.2.8";
+       sha256 = "1frvim9asp0849g7f5c1hcjkr82c9w27im479vmk6n4zzssvzach";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson algebraic-graphs aur base bytestring containers filepath
          hashable http-client http-types language-bash megaparsec
          network-uri prettyprinter prettyprinter-ansi-terminal rio scheduler
-         stm text time transformers typed-process versions
+         stm text time transformers typed-process unix versions
        ];
        executableHaskellDepends = [
          aeson aur base bytestring containers http-client http-client-tls
          megaparsec optparse-applicative prettyprinter
          prettyprinter-ansi-terminal rio scheduler text transformers
-         typed-process versions
+         typed-process unix versions
        ];
        testHaskellDepends = [
          base bytestring containers megaparsec rio tasty tasty-hunit text
···
      }:
      mkDerivation {
        pname = "autodocodec";
-       version = "0.0.1.0";
-       sha256 = "0g0k1c76nfkw8l5x6isz6fkci9bjn67qdpmjksf4qdfla28v35ha";
+       version = "0.0.1.1";
+       sha256 = "12wvqn2hqfi4fh4w53qs137x5cdbqwvlksbncnbcnzdlad7ncfqa";
        libraryHaskellDepends = [
          aeson base bytestring containers hashable mtl scientific text time
          unordered-containers validity validity-scientific vector
···
      }:
      mkDerivation {
        pname = "autodocodec-schema";
-       version = "0.1.0.0";
-       sha256 = "0qk1fjb47whpbnj2w776sk5mnb1m4z1dq6fmxhvjih3xsrpjq7s3";
+       version = "0.1.0.1";
+       sha256 = "1nzwbj3r5gps2lnriig38h1y51m4pd997z65kpsmxzcbyakdxjnd";
        libraryHaskellDepends = [
          aeson autodocodec base containers mtl text unordered-containers
          validity validity-aeson validity-containers validity-text
···
      }:
      mkDerivation {
        pname = "autodocodec-yaml";
-       version = "0.1.0.0";
-       sha256 = "1wa51mas9jxzhig651i9r21fxahk8rdwg7waxx4ilayzdfhaic4b";
+       version = "0.1.0.1";
+       sha256 = "1js3w0r7nrvl70vkkwblx8zqax22idblpdzs1ljr4x0jiwwji8bs";
        libraryHaskellDepends = [
          autodocodec autodocodec-schema base bytestring containers path
          path-io safe-coloured-text scientific text unordered-containers
···
     ({ mkDerivation, barbies, base, split, template-haskell }:
      mkDerivation {
        pname = "barbies-th";
-       version = "0.1.9";
-       sha256 = "1brikm7qr2yi3426vgwjjxjrvw060sb0v7jbxrhazjps28f6aa3n";
-       revision = "1";
-       editedCabalFile = "0iij1y72q28wvj8hfx000cpckl1wlcgj050380lx526cmwavy151";
+       version = "0.1.10";
+       sha256 = "0h16ywwf6dgazwnsqxl82l28vjx51gmh2xn8idlvc7kkl8ylgq54";
        libraryHaskellDepends = [ barbies base split template-haskell ];
        testHaskellDepends = [ barbies base ];
        description = "Create strippable HKD via TH";
···
      }:
      mkDerivation {
        pname = "bearriver";
-       version = "0.13.3";
-       sha256 = "0qakz6fidvhg121j442lsvcz9va0xa0rks41qj293mnrs8savv0p";
+       version = "0.13.4";
+       sha256 = "1c2w0ll84mrzkwg3314pnmasgaql0yjhrb5wy7zlm18s3bgpcysb";
        libraryHaskellDepends = [
          base dunai MonadRandom mtl simple-affine-space transformers
        ];
···
        libraryHaskellDepends = [ base category ];
        description = "Bifunctors";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bifunctors" = callPackage
···
        ];
        description = "A collection of various methods for reading and writing bini files";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "binrep" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, cereal, refined
+     , refined-with, text
+     }:
+     mkDerivation {
+       pname = "binrep";
+       version = "0.1.0";
+       sha256 = "10b65qdk4h96q44bl6ic8c4v2lfkr3vsm15zpia0dlikxnibvb8i";
+       libraryHaskellDepends = [
+         aeson base bytestring cereal refined refined-with text
+       ];
+       description = "Encode binary representations via types";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bins" = callPackage
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) bzip2;};
 
+  "bzlib-conduit-jappie" = callPackage
+    ({ mkDerivation, base, bindings-DSL, bytestring, bzip2, conduit
+     , data-default-class, hspec, mtl, random, resourcet
+     }:
+     mkDerivation {
+       pname = "bzlib-conduit-jappie";
+       version = "0.3.0.3";
+       sha256 = "10fvvcv205r45yk02fi4cyqq1r7f98hl5p4psfr3xixlzsyh6n8k";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bindings-DSL bytestring conduit data-default-class mtl
+         resourcet
+       ];
+       librarySystemDepends = [ bzip2 ];
+       libraryPkgconfigDepends = [ bzip2 ];
+       testHaskellDepends = [
+         base bindings-DSL bytestring conduit data-default-class hspec mtl
+         random resourcet
+       ];
+       benchmarkHaskellDepends = [
+         base bindings-DSL bytestring conduit data-default-class mtl
+         resourcet
+       ];
+       description = "Streaming compression/decompression via conduits";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {inherit (pkgs) bzip2;};
+
   "c-dsl" = callPackage
     ({ mkDerivation, base, language-c }:
      mkDerivation {
···
        libraryHaskellDepends = [ alg base ];
        description = "Cellular Automata";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ca-patterns" = callPackage
···
        ];
        description = "Compose a list of a project's transitive dependencies with their licenses";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "cabal-detailed-quickcheck" = callPackage
+    ({ mkDerivation, base, Cabal, QuickCheck }:
+     mkDerivation {
+       pname = "cabal-detailed-quickcheck";
+       version = "0.1.1.3";
+       sha256 = "1zy2b86ns5jhrl6z6qw6g1zq5nv3lpf4askpr40l9gid61h6mr01";
+       libraryHaskellDepends = [ base Cabal QuickCheck ];
+       description = "QuickCheck for Cabal tests";
+       license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        license = lib.licenses.mit;
      }) {};
 
+  "calligraphy" = callPackage
+    ({ mkDerivation, array, base, containers, directory, enummapset
+     , filepath, ghc, hspec, HUnit, mtl, optparse-applicative, process
+     , QuickCheck, text
+     }:
+     mkDerivation {
+       pname = "calligraphy";
+       version = "0.1.2";
+       sha256 = "08kiqp1z60hbfxm5s2d0hdr516gbq8fqyz0ddlr3vk0g9npm3nj2";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base containers directory enummapset filepath ghc mtl
+         optparse-applicative process text
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base containers hspec HUnit QuickCheck ];
+       description = "HIE-based Haskell call graph and source code visualizer";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "camfort" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, fgl, filepath, flint, fortran-src
···
        pname = "category";
        version = "0.2.5.0";
        sha256 = "0iya7q3b1z1bxv4amsibmc1lrmf7dng76nzcnanwy300jm1n42w7";
+       revision = "1";
+       editedCabalFile = "13yj1v414llr5cxdd5f3wdy75si2hj7f3k1f6w7kwj84gbrii5rr";
        libraryHaskellDepends = [ alg base dual transformers ];
        description = "Categorical types and classes";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "category-extras" = callPackage
···
      }:
      mkDerivation {
        pname = "cborg";
-       version = "0.2.6.0";
-       sha256 = "1mvsavi8ngsvmcvlmaygsnygf7hn8kdqdhfff91n1zajgpz577h6";
-       revision = "1";
-       editedCabalFile = "0ry5p8cnmm772m3z074azh1ldxvq851dmffsp2b7vljjhzd9j4sc";
+       version = "0.2.7.0";
+       sha256 = "076656vq2qabhdnwzifc5gsj20vwh69vhy19dh0qa1f2lqxrzfvq";
        libraryHaskellDepends = [
          array base bytestring containers deepseq ghc-bignum ghc-prim half
          primitive text
···
      }:
      mkDerivation {
        pname = "cborg-json";
-       version = "0.2.3.0";
-       sha256 = "1nsind3yiix6mb3xgwcnb267d8w9k0dvfnj78jc58gybx5hl9n53";
+       version = "0.2.4.0";
+       sha256 = "1h5i8sf1q1xr4c2y945vanj6n1wkkag1vflfjys7ygbgddbcq7rv";
        libraryHaskellDepends = [
          aeson aeson-pretty base cborg scientific text unordered-containers
          vector
···
        pname = "cci";
        version = "0.3.1";
        sha256 = "0pvap67fn9kmjvn2qqq3x99k3mzrrsnb6q6fhawvyxv8drihsfc7";
-       revision = "1";
-       editedCabalFile = "11s00cbbimpglashmp1vmw1xhd4y2g1spn01ajvx3sw6wdyh614n";
+       revision = "2";
+       editedCabalFile = "123jmn7lgz1hmkygjzqckffm77783pfzddnjyvvv7rsnpgl4ckqn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
···
      }:
      mkDerivation {
        pname = "clash-shake";
-       version = "0.2.2";
-       sha256 = "10gj6764qhdy6ki0dyy75ycpj5il26jgxxjcr0xy9kkixi3wgsrb";
+       version = "0.3.0";
+       sha256 = "1iprssnpxykh9fjgckjnh5qlmnf1drgzjjfcq9fxyqs755y38vbi";
        libraryHaskellDepends = [
          aeson base bytestring clash-ghc clash-lib clash-prelude directory
          shake split stache text unordered-containers
···
      }:
      mkDerivation {
        pname = "clckwrks";
-       version = "0.28.0";
-       sha256 = "11cr4mql6jhskhk1hg2c7kkvv005bha7y9b3ccpgy1147grnp00m";
+       version = "0.28.0.1";
+       sha256 = "1h18gh6042qq7qphiqdj9ww9k2pghj3dzz33rdh6w4jlx967w6bw";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          acid-state aeson aeson-qq attoparsec base blaze-html bytestring
···
      }:
      mkDerivation {
        pname = "clckwrks-plugin-page";
-       version = "0.4.3.25";
-       sha256 = "0ii9984y7792i7kiwnqmgn9mfyky2k9dkx3fnzkirypqbxyri92s";
+       version = "0.4.3.26";
+       sha256 = "1h348cgxrvj6p4kd4vzfkdjvx592p7yb16mmxp27k61jvncg1vjw";
        libraryHaskellDepends = [
          acid-state aeson attoparsec base clckwrks containers directory
          filepath happstack-hsp happstack-server hsp hsx2hs ixset mtl
···
      }:
      mkDerivation {
        pname = "clckwrks-plugin-redirect";
-       version = "0.0.1.2";
-       sha256 = "1vb0knjy0qkbpzni10bgvznnjxc7bv7pbp1l9frdffdsrssgyx8w";
+       version = "0.0.1.3";
+       sha256 = "15qcqrrznx7wz0anfwvs0rr3jl51ifcb0gxlr236c4c4xx8wfhna";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "clckwrks-theme-bootstrap";
-       version = "0.4.3.2";
-       sha256 = "0ag94kc0csjnh88vw6ljifv6cqqwc8wizyizqk0mj4qpp73z6qd2";
+       version = "0.4.3.5";
+       sha256 = "07gms8mcp4lbi6fqxanzg2z7ybjhisxaal7yix3039glh54d2gv3";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base clckwrks happstack-authenticate hsp hsx-jmacro hsx2hs jmacro
···
        libraryHaskellDepends = [ base category unconstrained ];
        description = "Reified constraints";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "constraint-classes" = callPackage
···
        libraryHaskellDepends = [ base category constraint reflection ];
        description = "Constraint reflection";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "constraint-tuples" = callPackage
···
      }) {};
 
   "context" = callPackage
-    ({ mkDerivation, async, base, containers, ghc-prim, hspec
-     , hspec-discover
+    ({ mkDerivation, async, base, containers, exceptions, ghc-prim
+     , hspec, hspec-discover
      }:
      mkDerivation {
        pname = "context";
-       version = "0.1.1.1";
-       sha256 = "0zn8hnyf04q7brchll3xnk0ifxadl050wric191irmnl29m6p5k8";
-       libraryHaskellDepends = [ base containers ];
+       version = "0.2.0.0";
+       sha256 = "1s915v2wbmhwp3qwk5p7n1iz510wfdmi4nq2zg1m04q7dpzhl0xz";
+       libraryHaskellDepends = [ base containers exceptions ];
        testHaskellDepends = [ async base ghc-prim hspec ];
        testToolDepends = [ hspec-discover ];
        description = "Thread-indexed, nested contexts";
···
      }:
      mkDerivation {
        pname = "context-http-client";
-       version = "0.1.0.0";
-       sha256 = "0ad917jnzqd2idzh6a5j9nvjf2pg7l968vmn38cxgh9hfq3yhwm7";
+       version = "0.2.0.0";
+       sha256 = "0d7hdqcvfay8m1inbl19z4hj8qqi2a00qsxh7n7s03075rd8wzs0";
        libraryHaskellDepends = [ base context http-client ];
        testHaskellDepends = [
          async base bytestring case-insensitive context hspec http-client
···
      }) {};
 
   "context-resource" = callPackage
-    ({ mkDerivation, async, base, context, hspec, hspec-discover }:
+    ({ mkDerivation, async, base, context, exceptions, hspec
+     , hspec-discover
+     }:
      mkDerivation {
        pname = "context-resource";
-       version = "0.1.0.0";
-       sha256 = "0695m9hnx8grfmyy7mzd6n3426qc18sh14hy6glhr5nwj9c4k4c2";
-       libraryHaskellDepends = [ base context ];
+       version = "0.2.0.0";
+       sha256 = "0jjy6i6vcg3b9chrkw7l2yza8kdxl8d4bdlrqp0anpaxwm1q34da";
+       libraryHaskellDepends = [ base context exceptions ];
        testHaskellDepends = [ async base context hspec ];
        testToolDepends = [ hspec-discover ];
        description = "Thread-safe, pool-compatible resource provider";
···
      }:
      mkDerivation {
        pname = "context-wai-middleware";
-       version = "0.1.0.0";
-       sha256 = "0bisqsngccddkamf60qyk4h9w4w80ppks51i4p9bl39kmf7hd65l";
+       version = "0.2.0.0";
+       sha256 = "017zwjq4kl3jjmrdp0x6zxbsd9k5xnvcgf4r1cjk7cnlch36cwmn";
        libraryHaskellDepends = [ base context wai ];
        testHaskellDepends = [
          async base bytestring case-insensitive context hspec http-client
···
        license = lib.licenses.mit;
      }) {};
 
+  "core-data_0_3_2_2" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, core-text
+     , hashable, prettyprinter, scientific, text, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "core-data";
+       version = "0.3.2.2";
+       sha256 = "000ffh2lrv5yl9gybx3i8gp66f1vd1w6mhih8bipxf7fzgsn6pik";
+       libraryHaskellDepends = [
+         aeson base bytestring containers core-text hashable prettyprinter
+         scientific text unordered-containers vector
+       ];
+       description = "Convenience wrappers around common data structures and encodings";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "core-haskell" = callPackage
     ({ mkDerivation, base, haskeline, haskell-src-exts, hint }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
+  "core-program_0_4_6_1" = callPackage
+    ({ mkDerivation, async, base, bytestring, chronologique, core-data
+     , core-text, directory, exceptions, filepath, fsnotify, hashable
+     , hourglass, mtl, prettyprinter, safe-exceptions, stm
+     , template-haskell, terminal-size, text, text-short, transformers
+     , typed-process, unix
+     }:
+     mkDerivation {
+       pname = "core-program";
+       version = "0.4.6.1";
+       sha256 = "0vjrffccnh7vl86mfm7i4rfwk9pzsg47g0gd4pg6fsdcs6118amq";
+       libraryHaskellDepends = [
+         async base bytestring chronologique core-data core-text directory
+         exceptions filepath fsnotify hashable hourglass mtl prettyprinter
+         safe-exceptions stm template-haskell terminal-size text text-short
+         transformers typed-process unix
+       ];
+       description = "Opinionated Haskell Interoperability";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "core-telemetry" = callPackage
     ({ mkDerivation, async, base, bytestring, chronologique, core-data
      , core-program, core-text, exceptions, http-streams, io-streams
···
        license = lib.licenses.mit;
      }) {};
 
+  "core-telemetry_0_2_0_1" = callPackage
+    ({ mkDerivation, async, base, bytestring, chronologique, core-data
+     , core-program, core-text, exceptions, http-streams, io-streams
+     , mtl, network-info, random, safe-exceptions, scientific, stm
+     , template-haskell, text, unix
+     }:
+     mkDerivation {
+       pname = "core-telemetry";
+       version = "0.2.0.1";
+       sha256 = "1l302ncnv1w3p84v16acxvkyr6kvrr6385i7qdrmqi0a8yfwizb0";
+       libraryHaskellDepends = [
+         async base bytestring chronologique core-data core-program
+         core-text exceptions http-streams io-streams mtl network-info
+         random safe-exceptions scientific stm template-haskell text unix
+       ];
+       description = "Advanced telemetry";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "core-text" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, colour, deepseq
      , fingertree, hashable, prettyprinter, template-haskell, text
···
        ];
        description = "A rope type based on a finger tree over UTF-8 fragments";
        license = lib.licenses.mit;
+     }) {};
+
+  "core-text_0_3_7_1" = callPackage
+    ({ mkDerivation, ansi-terminal, base, bytestring, colour, deepseq
+     , fingertree, hashable, prettyprinter, template-haskell, text
+     , text-short
+     }:
+     mkDerivation {
+       pname = "core-text";
+       version = "0.3.7.1";
+       sha256 = "11l89p9fn05l8h7dx6mpw4mhwhcxhdl2879lj628bxjal3f2fys3";
+       libraryHaskellDepends = [
+         ansi-terminal base bytestring colour deepseq fingertree hashable
+         prettyprinter template-haskell text text-short
+       ];
+       description = "A rope type based on a finger tree over UTF-8 fragments";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "core-warn" = callPackage
···
        ];
        description = "Interoperability with Servant";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "core-webserver-warp" = callPackage
···
      }:
      mkDerivation {
        pname = "core-webserver-warp";
-       version = "0.1.1.0";
-       sha256 = "0yfd2037bq6vljixkhrk2v2mlywj2br16pf5dpz2vahjpk0079yj";
+       version = "0.1.1.3";
+       sha256 = "1yjy5y0lvwkjyribhqavcda57s30jc7xjacng2g3p256kfp7mc2r";
        libraryHaskellDepends = [
          async base bytestring core-data core-program core-telemetry
          core-text http-types http2 mtl safe-exceptions vault wai warp
        ];
        description = "Interoperability with Wai/Warp";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "corebot-bliki" = callPackage
···
        ];
        description = "Countable, Searchable, Finite, Empty classes";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "countable_1_2" = callPackage
+    ({ mkDerivation, base, bytestring, silently, tasty, tasty-golden
+     , tasty-hunit
+     }:
+     mkDerivation {
+       pname = "countable";
+       version = "1.2";
+       sha256 = "119v5ms4nyxikfwlmz71qk9gqp53zkpyxc6wm3qp5bm9b6n1ff47";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base bytestring silently tasty tasty-golden tasty-hunit
+       ];
+       description = "Countable, Searchable, Finite, Empty classes";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "countable-inflections" = callPackage
···
      }:
      mkDerivation {
        pname = "cql";
-       version = "4.0.3";
-       sha256 = "1b6bqhg3rf2kk7i81l4vsgyp7zxiycifdrsj8qa4sqx78m72dmxh";
+       version = "4.0.4";
+       sha256 = "04s947r9wsqamqx3sq0h41l0mwxcw7pqc11jlrj8r94wgiikpkh2";
        libraryHaskellDepends = [
          base bytestring cereal containers Decimal iproute network
          template-haskell text time transformers uuid vector
···
        license = "GPL";
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "csv-sip" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, containers, hspec, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "csv-sip";
+       version = "0.1.0";
+       sha256 = "1m33kw4rgzq7ivhr44giagp0b2xx0h9q0ipidll8xrrklvxzkcsc";
+       libraryHaskellDepends = [
+         base bytestring conduit containers text transformers
+       ];
+       testHaskellDepends = [
+         base bytestring conduit containers hspec text transformers
+       ];
+       description = "extracts data from a CSV file";
+       license = lib.licenses.gpl3Plus;
      }) {};
 
   "csv-table" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "derivingvia-extras" = callPackage
+    ({ mkDerivation, base, hashable }:
+     mkDerivation {
+       pname = "derivingvia-extras";
+       version = "0.1.0.0";
+       sha256 = "11fsx8pbxqp968pgvms6qzw5x871r3c94m812nz81fpqkm6mv5cz";
+       libraryHaskellDepends = [ base hashable ];
+       description = "DerivingVia extras - Miscellaneous /via/ types";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "derp" = callPackage
     ({ mkDerivation, base, containers }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "dhall-text-shell" = callPackage
+    ({ mkDerivation, base, containers, dhall, filepath
+     , optparse-applicative, process, text
+     }:
+     mkDerivation {
+       pname = "dhall-text-shell";
+       version = "0.2.0.0";
+       sha256 = "10i1i7fk9y5hsxjjb87jbfnprg7nkrvpax6kd4blfphpzs2mpz5b";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers dhall filepath optparse-applicative process text
+       ];
+       executableHaskellDepends = [
+         base containers dhall filepath optparse-applicative process text
+       ];
+       description = "Render dhall text with shell commands as function arguments";
+       license = lib.licenses.mit;
+     }) {};
+
   "dhall-to-cabal" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, contravariant
      , dhall, Diff, directory, filepath, microlens, optparse-applicative
···
        description = "An EDSL for teaching Haskell with diagrams - functions";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "diagnose" = callPackage
+    ({ mkDerivation, base, data-default, hashable, prettyprinter
+     , prettyprinter-ansi-terminal, unordered-containers, wcwidth
+     }:
+     mkDerivation {
+       pname = "diagnose";
+       version = "1.8.2";
+       sha256 = "11hyd08aixx795mf79ybzkz59s68v59rdl6lkyjvzn06sh1fvvdc";
+       libraryHaskellDepends = [
+         base data-default hashable prettyprinter
+         prettyprinter-ansi-terminal unordered-containers wcwidth
+       ];
+       testHaskellDepends = [
+         base data-default hashable prettyprinter
+         prettyprinter-ansi-terminal unordered-containers wcwidth
+       ];
+       description = "Beautiful error reporting done easily";
+       license = lib.licenses.bsd3;
      }) {};
 
   "diagrams" = callPackage
···
      }:
      mkDerivation {
        pname = "dunai";
-       version = "0.8.1";
-       sha256 = "1zijhrk50cyyrb6jqlf8q0hh87lbfy5k9iy6w2az66nm89ckxrv9";
+       version = "0.8.2";
+       sha256 = "1hcjzd6zki10lkh6f11naxqrnkdmiqm4hwyj5acj4naqkakc6mmp";
        libraryHaskellDepends = [
          base MonadRandom simple-affine-space transformers transformers-base
        ];
···
     ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }:
      mkDerivation {
        pname = "dunai-test";
-       version = "0.8.1";
-       sha256 = "1iy989wz4jnn9g892p7n0f1hj2hd61a01vxnqz5fr0yppbsckp3h";
+       version = "0.8.2";
+       sha256 = "0cicvzp604945mmlnrxwkkcyl01id933jrnnrv3y0c5xqlly2y9r";
        libraryHaskellDepends = [
          base dunai normaldistribution QuickCheck
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "exact-pi_0_5_0_2" = callPackage
+    ({ mkDerivation, base, numtype-dk, QuickCheck, tasty, tasty-hunit
+     , tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "exact-pi";
+       version = "0.5.0.2";
+       sha256 = "1xmc3vlzfccrn5szglnxx13akxw2xacgl40kqh0kiw82d58x47a4";
+       libraryHaskellDepends = [ base numtype-dk ];
+       testHaskellDepends = [
+         base numtype-dk QuickCheck tasty tasty-hunit tasty-quickcheck
+       ];
+       description = "Exact rational multiples of pi (and integer powers of pi)";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "exact-real" = callPackage
     ({ mkDerivation, base, Cabal, cabal-doctest, checkers, criterion
      , doctest, groups, integer-gmp, QuickCheck, random, tasty
···
        libraryHaskellDepends = [ base template-haskell ];
        description = "Exception type hierarchy with TemplateHaskell";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "exception-hierarchy_0_1_0_7" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "exception-hierarchy";
+       version = "0.1.0.7";
+       sha256 = "14kk0rync05rq2adx5lk59y56h97s0yv7mqfn2grhhwqb10maqj0";
+       libraryHaskellDepends = [ base template-haskell ];
+       description = "Exception type hierarchy with TemplateHaskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "exception-mailer" = callPackage
···
        libraryHaskellDepends = [ base base-unicode-symbols util ];
        description = "Dependent sum type";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "exist-instances" = callPackage
···
        ];
        description = "Instances for \"exist\" package (requires more language extensions and dependencies)";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "existential" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "extensioneer" = callPackage
+    ({ mkDerivation, base, Cabal, containers, directory, hpack, mtl
+     , optparse-applicative, yaml
+     }:
+     mkDerivation {
+       pname = "extensioneer";
+       version = "0.1.0.0";
+       sha256 = "02n7ajra4vx63wjjj4dj54md87hk0cjz61bh6m3ql37h97iqsiqx";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base Cabal containers directory hpack mtl optparse-applicative yaml
+       ];
+       description = "Inspect extensions in cabal and hpack files";
+       license = lib.licenses.mit;
+     }) {};
+
   "extensions" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, colourista, containers
      , directory, filepath, ghc-boot-th, hedgehog, hspec, hspec-hedgehog
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "Lists with fair choice";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fair-predicates" = callPackage
···
      }:
      mkDerivation {
        pname = "fb";
-       version = "2.1.1";
-       sha256 = "0j2rckrv1aksfp2wyiyffqg40jl927vs97fk2lyzkscz673jd9s9";
+       version = "2.1.1.1";
+       sha256 = "18hqmhfzniydmxwi8b21iz04pc6x8hdy8pj6960ihrk20ddkih3d";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring conduit conduit-extra cryptonite
          data-default http-client http-conduit http-types memory
···
      }:
      mkDerivation {
        pname = "fbrnch";
-       version = "1.0.0";
-       sha256 = "1j5whbx72q7jvjkv952y8qmgqkm19dprn6p1glvgsck8nhmffkkd";
+       version = "1.1";
+       sha256 = "11vhm176dm2i4zy7ipg20rsmp7rdabq8gh29byflqxm5s5wp86y6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }) {};
 
   "fcf-containers" = callPackage
-    ({ mkDerivation, base, doctest, first-class-families, Glob }:
+    ({ mkDerivation, base, doctest, first-class-families, ghc-prim
+     , Glob, mtl
+     }:
      mkDerivation {
        pname = "fcf-containers";
-       version = "0.6.0";
-       sha256 = "09sr1xqdjzfk5gysd7hi66xadwcfrjq4q3vakmdilc14lw833wgp";
+       version = "0.7.0";
+       sha256 = "0ai2hmcva84z29jxr3inngnicx0wn05vnh9lw460fcfckdfxf5xf";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base first-class-families ];
+       libraryHaskellDepends = [ base first-class-families ghc-prim mtl ];
        executableHaskellDepends = [ base first-class-families ];
-       testHaskellDepends = [ base doctest first-class-families Glob ];
+       testHaskellDepends = [
+         base doctest first-class-families ghc-prim Glob
+       ];
        description = "Data structures and algorithms for first-class-families";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        libraryHaskellDepends = [ base transformers util ];
        description = "Foldable types with at least 1 element";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "foldl" = callPackage
···
      }:
      mkDerivation {
        pname = "genvalidity-aeson";
-       version = "1.0.0.0";
-       sha256 = "1k28vl7i2idv44962wspvhpqpfznj52ckd3g7h580894vghhwi89";
+       version = "1.0.0.1";
+       sha256 = "0j5sms6f3ivxn981gzqsyhks2q2fws8xdbnnffb209dr0afg00b1";
        libraryHaskellDepends = [
          aeson base genvalidity genvalidity-scientific genvalidity-text
          genvalidity-unordered-containers genvalidity-vector QuickCheck
···
          aeson base criterion genvalidity-criterion
        ];
        description = "GenValidity support for aeson";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "genvalidity-appendful" = callPackage
+    ({ mkDerivation, appendful, base, containers, criterion
+     , genvalidity, genvalidity-containers, genvalidity-criterion
+     , genvalidity-hspec, genvalidity-hspec-aeson, genvalidity-time
+     , genvalidity-uuid, hspec, mtl, pretty-show, QuickCheck, random
+     , time, uuid
+     }:
+     mkDerivation {
+       pname = "genvalidity-appendful";
+       version = "0.0.0.0";
+       sha256 = "0sri0xdaqxpaapjspq4gipmvh7az3dilbzd4v5ihgcsjfk7kxmaj";
+       libraryHaskellDepends = [
+         appendful base containers genvalidity genvalidity-containers
+         genvalidity-time QuickCheck
+       ];
+       testHaskellDepends = [
+         appendful base containers genvalidity-hspec genvalidity-hspec-aeson
+         genvalidity-uuid hspec mtl pretty-show QuickCheck random time uuid
+       ];
+       benchmarkHaskellDepends = [
+         appendful base criterion genvalidity-criterion
+       ];
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
      }) {};
···
          QuickCheck
        ];
        description = "GenValidity support for ByteString";
+       license = lib.licenses.mit;
+     }) {};
+
+  "genvalidity-case-insensitive" = callPackage
+    ({ mkDerivation, base, case-insensitive, criterion, genvalidity
+     , genvalidity-criterion, genvalidity-hspec, hspec, QuickCheck
+     , validity-case-insensitive
+     }:
+     mkDerivation {
+       pname = "genvalidity-case-insensitive";
+       version = "0.0.0.0";
+       sha256 = "1lmg44ihas98h02121bv1wy59k0za65nsgb64nh0al5bs6m7vsrl";
+       libraryHaskellDepends = [
+         base case-insensitive genvalidity validity-case-insensitive
+       ];
+       testHaskellDepends = [
+         base case-insensitive genvalidity-hspec hspec
+       ];
+       benchmarkHaskellDepends = [
+         base case-insensitive criterion genvalidity genvalidity-criterion
+         QuickCheck
+       ];
+       description = "GenValidity support for case-insensitive";
        license = lib.licenses.mit;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "ghc-events";
-       version = "0.17.0.2";
-       sha256 = "0dkzxpfiqpd1i1lhrssp1b242111228ap113iavarr9hb7y8rl72";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         array base binary bytestring containers text vector
-       ];
-       executableHaskellDepends = [ base containers ];
-       testHaskellDepends = [ base ];
-       description = "Library and tool for parsing .eventlog files from GHC";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ghc-events_0_17_0_3" = callPackage
-    ({ mkDerivation, array, base, binary, bytestring, containers, text
-     , vector
-     }:
-     mkDerivation {
-       pname = "ghc-events";
        version = "0.17.0.3";
        sha256 = "0m50x2ycv43d7yzwksbs1zc11wlyiszjz662fj47v9r7hacx335v";
        isLibrary = true;
···
        testHaskellDepends = [ base ];
        description = "Library and tool for parsing .eventlog files from GHC";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-events-analyze" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-exactprint_1_4_1" = callPackage
-    ({ mkDerivation }:
-     mkDerivation {
-       pname = "ghc-exactprint";
-       version = "1.4.1";
-       sha256 = "0q9z43753arxbcs6mz26kz4dsz0c2i5hkxa125gl36vsipxfrq92";
-       revision = "1";
-       editedCabalFile = "00wvn8j7439r5pp9wjqasv710amrsf34qpa3czxja2khg9jdnngj";
-       isLibrary = true;
-       isExecutable = true;
-       description = "ExactPrint for GHC";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "ghc-exactprint_1_5_0" = callPackage
     ({ mkDerivation }:
      mkDerivation {
···
        description = "ExactPrint for GHC";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "ghc-gc-hook" = callPackage
+    ({ mkDerivation, base, clock }:
+     mkDerivation {
+       pname = "ghc-gc-hook";
+       version = "0.2.0.0";
+       sha256 = "0k7w7imrlg2gdcibkm6b02phk163xv4lnsab316jcfdid53zi7j2";
+       libraryHaskellDepends = [ base clock ];
+       testHaskellDepends = [ base clock ];
+       description = "GHC garbage collection hook";
+       license = lib.licenses.bsd3;
      }) {};
 
   "ghc-gc-tune" = callPackage
···
        pname = "ghc-heap";
        version = "9.2.1";
        sha256 = "10d7p12p9v5z426rxx1cyhk90hx6ab6l98bk1v4a9gk551fcqsv9";
+       revision = "1";
+       editedCabalFile = "11kwkc96vk0jd7lpm0bz5x2ji4qc222wm2lc3y4lfx0knir2kyi6";
        libraryHaskellDepends = [ base containers ghc-prim rts ];
        description = "Functions for walking GHC's heap";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, aeson, aeson-pretty, array, async, base
      , base16-bytestring, binary, bytestring, case-insensitive
      , containers, cryptohash-sha1, data-default, deepseq, dependent-map
-     , dependent-sum, Diff, directory, dlist, exceptions, extra
-     , filepath, fingertree, focus, fuzzy, ghc, ghc-boot, ghc-boot-th
-     , ghc-check, ghc-exactprint, ghc-paths, ghc-trace-events
-     , ghc-typelits-knownnat, gitrev, Glob, haddock-library, hashable
-     , heapsize, hie-bios, hie-compat, hiedb, hls-graph, hls-plugin-api
-     , hp2pretty, hslogger, implicit-hie, implicit-hie-cradle, lens
-     , list-t, lsp, lsp-test, lsp-types, monoid-subclasses, mtl
-     , network-uri, opentelemetry, optparse-applicative, parallel
-     , prettyprinter, prettyprinter-ansi-terminal, process, QuickCheck
+     , dependent-sum, Diff, directory, dlist, enummapset, exceptions
+     , extra, filepath, fingertree, focus, fuzzy, ghc, ghc-boot
+     , ghc-boot-th, ghc-check, ghc-exactprint, ghc-paths
+     , ghc-trace-events, ghc-typelits-knownnat, gitrev, Glob
+     , haddock-library, hashable, heapsize, hie-bios, hie-compat, hiedb
+     , hls-graph, hls-plugin-api, hp2pretty, hslogger, implicit-hie
+     , implicit-hie-cradle, lens, list-t, lsp, lsp-test, lsp-types
+     , monoid-subclasses, mtl, network-uri, opentelemetry
+     , optparse-applicative, parallel, prettyprinter
+     , prettyprinter-ansi-terminal, process, QuickCheck
      , quickcheck-instances, random, record-dot-preprocessor
      , record-hasfield, regex-tdfa, retrie, rope-utf16-splay, safe
      , safe-exceptions, shake, shake-bench, sorted-list, sqlite-simple
···
      }:
      mkDerivation {
        pname = "ghcide";
-       version = "1.6.0.1";
-       sha256 = "14k1x54kk27yaaw8n0iq1kq1hl4j417bgbvdiy0a6zg6h7rdnwzw";
+       version = "1.7.0.0";
+       sha256 = "097vpp1gds36ijldz29bsk71pxc82l966ka578cxsrcdc3g3ll1b";
+       revision = "1";
+       editedCabalFile = "0xvszq1jad6126vg73qys8z9jys7b1gs75fsaa4kq5dnrfg8hpx3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty array async base base16-bytestring binary
          bytestring case-insensitive containers cryptohash-sha1 data-default
-         deepseq dependent-map dependent-sum Diff directory dlist exceptions
-         extra filepath fingertree focus fuzzy ghc ghc-boot ghc-boot-th
+         deepseq dependent-map dependent-sum Diff directory dlist enummapset
+         exceptions extra filepath fingertree focus ghc ghc-boot ghc-boot-th
          ghc-check ghc-exactprint ghc-paths ghc-trace-events Glob
          haddock-library hashable heapsize hie-bios hie-compat hiedb
          hls-graph hls-plugin-api hslogger implicit-hie-cradle lens list-t
···
        ];
        testHaskellDepends = [
          aeson async base binary bytestring containers data-default
-         directory extra filepath ghc ghc-typelits-knownnat haddock-library
-         hls-graph hls-plugin-api lens list-t lsp lsp-test lsp-types
-         network-uri optparse-applicative process QuickCheck
-         quickcheck-instances random record-dot-preprocessor record-hasfield
-         regex-tdfa rope-utf16-splay safe safe-exceptions shake
-         sqlite-simple stm stm-containers tasty tasty-expected-failure
-         tasty-hunit tasty-quickcheck tasty-rerun text unordered-containers
+         directory extra filepath fuzzy ghc ghc-typelits-knownnat
+         haddock-library hls-graph hls-plugin-api lens list-t lsp lsp-test
+         lsp-types monoid-subclasses network-uri optparse-applicative
+         parallel process QuickCheck quickcheck-instances random
+         record-dot-preprocessor record-hasfield regex-tdfa rope-utf16-splay
+         safe safe-exceptions shake sqlite-simple stm stm-containers tasty
+         tasty-expected-failure tasty-hunit tasty-quickcheck tasty-rerun
+         text unordered-containers vector
        ];
        testToolDepends = [ implicit-hie ];
        benchmarkHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Access to the GitHub API, v3";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "github_0_28" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, base16-bytestring
+     , binary, binary-instances, bytestring, containers, cryptohash-sha1
+     , deepseq, deepseq-generics, exceptions, file-embed, hashable
+     , hspec, hspec-discover, http-client, http-client-tls
+     , http-link-header, http-types, iso8601-time, mtl, network-uri
+     , tagged, text, time-compat, tls, transformers, transformers-compat
+     , unordered-containers, vector, vector-instances
+     }:
+     mkDerivation {
+       pname = "github";
+       version = "0.28";
+       sha256 = "142l0zff852606hkpvkhvagp6h3ziq2z2x7x2pa77q5ymyq48089";
+       libraryHaskellDepends = [
+         aeson base base-compat base16-bytestring binary binary-instances
+         bytestring containers cryptohash-sha1 deepseq deepseq-generics
+         exceptions hashable http-client http-client-tls http-link-header
+         http-types iso8601-time mtl network-uri tagged text time-compat tls
+         transformers transformers-compat unordered-containers vector
+         vector-instances
+       ];
+       testHaskellDepends = [
+         aeson base base-compat bytestring file-embed hspec tagged text
+         unordered-containers vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Access to the GitHub API, v3";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "github-backup" = callPackage
···
      }:
      mkDerivation {
        pname = "gopro-plus";
-       version = "0.6.5.0";
-       sha256 = "09hj57r77r9mx2dy830n9qv3ap2nsg8a94gmpzf69zddqvk1fhm8";
+       version = "0.6.5.1";
+       sha256 = "06sasqagh4xa6gkhgjxf7jpvwfp9q27r0qnpr7rq0dxwsbrpqgnp";
        libraryHaskellDepends = [
          aeson base bytestring containers exceptions filepath
          generic-deriving generic-random lens lens-aeson monad-logger mtl
···
     ({ mkDerivation, attoparsec, base, Cabal, cabal-doctest, checkers
      , containers, criterion, deepseq, doctest, input-parsers
      , markdown-unlit, monoid-subclasses, parsers, QuickCheck
-     , rank2classes, size-based, tasty, tasty-quickcheck, testing-feat
-     , text, transformers, witherable
+     , rank2classes, tasty, tasty-quickcheck, text, transformers
+     , witherable
      }:
      mkDerivation {
        pname = "grammatical-parsers";
-       version = "0.5.2";
-       sha256 = "1xnm5j0lznabscpswzvxjccwxb6c8js7jg3z1ddd60gffq69wpip";
+       version = "0.6";
+       sha256 = "1ck7zv110yrwz04q10j38wx6ipap88np9px6l94rxbha1m1k7nhi";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        ];
        testHaskellDepends = [
          base checkers containers doctest monoid-subclasses parsers
-         QuickCheck rank2classes size-based tasty tasty-quickcheck
-         testing-feat witherable
+         QuickCheck rank2classes tasty tasty-quickcheck witherable
        ];
        testToolDepends = [ markdown-unlit ];
        benchmarkHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "hackage-cli" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
+     , deepseq, directory, filepath, http-io-streams, io-streams
+     , microlens, microlens-mtl, microlens-th, mtl, netrc
+     , optparse-applicative, pretty, process-extras, semigroups
+     , stringsearch, tagsoup, tar, tasty, tasty-golden, text, time
+     , unordered-containers, zlib
+     }:
+     mkDerivation {
+       pname = "hackage-cli";
+       version = "0.0.3.6";
+       sha256 = "1wnh3571mgwyl9c5bfkwvr4rvsnw41qb9mlz1nda1ya53qfdjl4p";
+       isLibrary = false;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring Cabal containers mtl pretty
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring Cabal containers deepseq directory filepath
+         http-io-streams io-streams microlens microlens-mtl microlens-th mtl
+         netrc optparse-applicative process-extras semigroups stringsearch
+         tagsoup tar text time unordered-containers zlib
+       ];
+       testHaskellDepends = [
+         base bytestring Cabal filepath tasty tasty-golden
+       ];
+       doHaddock = false;
+       description = "CLI tool for Hackage";
+       license = lib.licenses.gpl3Plus;
+     }) {};
+
   "hackage-db" = callPackage
     ({ mkDerivation, aeson, base, bytestring, Cabal, containers
      , directory, exceptions, filepath, tar, time, utf8-string
···
      }:
      mkDerivation {
        pname = "happstack-authenticate";
-       version = "2.6.0";
-       sha256 = "0sqldnhfp631vb3v69zm856zax89mgykvj4f9siisqn41qz097zx";
+       version = "2.6.1";
+       sha256 = "1kyh4l3c4xf6ykjmjvza44d0mf69wpwgi7v88g7lh3ag26m455w3";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          acid-state aeson authenticate base base64-bytestring boomerang
···
      }:
      mkDerivation {
        pname = "happstack-foundation";
-       version = "0.5.9.1";
-       sha256 = "05fcvwa25x993ba8h034877di4y1m3yp5f5fvx4jxdybpf868jnn";
+       version = "0.5.9.3";
+       sha256 = "1qm6kk5p5j7gvr6ckjibls5pid3qqihv9csd50q5yb1vzdqv1pii";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          acid-state base happstack-hsp happstack-server hsp lifted-base
···
      }:
      mkDerivation {
        pname = "happstack-hsp";
-       version = "7.3.7.5";
-       sha256 = "1krjas0id8an3ry83xrgxl9cb18n17r394ivz05c45mwan6sbpqf";
+       version = "7.3.7.6";
+       sha256 = "1y23yzppvxjhmvaq9yl02v8mp6ww91jpsvqfhpzxkw1jccz54bcq";
        libraryHaskellDepends = [
          base bytestring happstack-server harp hsp hsx2hs mtl syb text
          utf8-string
···
      }:
      mkDerivation {
        pname = "happstack-jmacro";
-       version = "7.0.12.3";
-       sha256 = "1phhy9sq7hiz3c50k5wyclrsjqacw8mcdyg80h3xi43zgjmff23w";
+       version = "7.0.12.4";
+       sha256 = "1zqfivzwq6wfwfgds5icy5rs5vrxiw9w1wzxn5jlqn7zkz3svbl9";
        libraryHaskellDepends = [
          base base64-bytestring bytestring cereal digest happstack-server
          jmacro text utf8-string wl-pprint-text
···
     ({ mkDerivation, base, bytestring, happstack-server, mtl, text }:
      mkDerivation {
        pname = "happstack-lite";
-       version = "7.3.7";
-       sha256 = "12vyyjl0n9dqp8mh5279930rnbwaxxlzw34651sa7h9gir9hv1zv";
+       version = "7.3.8";
+       sha256 = "0bvcgacsngpj92ldb2fd7yj67im0bn4jnd5a1ldpbk43w85f91pk";
        libraryHaskellDepends = [
          base bytestring happstack-server mtl text
        ];
···
      }:
      mkDerivation {
        pname = "happstack-server-tls";
-       version = "7.2.1.1";
-       sha256 = "0bply7dxz2046h0v0ydkicjvl491k0llapf2shxjqnskjjr5rqnk";
+       version = "7.2.1.2";
+       sha256 = "1qij3hx3y54s3vvcs7z656144cbp94aigy84ywfyp8238f4p5yq5";
        libraryHaskellDepends = [
          base bytestring extensible-exceptions happstack-server hslogger
          HsOpenSSL network sendfile time unix
···
      , cryptohash-sha1, data-default, deepseq, directory, extra
      , filepath, ghc, ghc-boot-th, ghc-paths, ghcide, githash, gitrev
      , hashable, hie-bios, hiedb, hls-alternate-number-format-plugin
-     , hls-call-hierarchy-plugin, hls-class-plugin, hls-eval-plugin
-     , hls-explicit-imports-plugin, hls-floskell-plugin
-     , hls-fourmolu-plugin, hls-graph, hls-haddock-comments-plugin
-     , hls-hlint-plugin, hls-module-name-plugin, hls-ormolu-plugin
-     , hls-plugin-api, hls-pragmas-plugin
-     , hls-qualify-imported-names-plugin, hls-refine-imports-plugin
-     , hls-retrie-plugin, hls-selection-range-plugin, hls-splice-plugin
-     , hls-test-utils, hslogger, hspec-expectations, lens, lens-aeson
-     , lsp, lsp-test, lsp-types, mtl, optparse-applicative
-     , optparse-simple, process, regex-tdfa, safe-exceptions
-     , sqlite-simple, stm, temporary, text, transformers
-     , unordered-containers
+     , hls-call-hierarchy-plugin, hls-change-type-signature-plugin
+     , hls-class-plugin, hls-eval-plugin, hls-explicit-imports-plugin
+     , hls-floskell-plugin, hls-fourmolu-plugin, hls-graph
+     , hls-haddock-comments-plugin, hls-hlint-plugin
+     , hls-module-name-plugin, hls-ormolu-plugin, hls-plugin-api
+     , hls-pragmas-plugin, hls-qualify-imported-names-plugin
+     , hls-refine-imports-plugin, hls-rename-plugin, hls-retrie-plugin
+     , hls-selection-range-plugin, hls-splice-plugin, hls-test-utils
+     , hspec-expectations, lens, lens-aeson, lsp, lsp-test, lsp-types
+     , mtl, optparse-applicative, optparse-simple, prettyprinter
+     , process, regex-tdfa, safe-exceptions, sqlite-simple, stm
+     , temporary, text, transformers, unix, unordered-containers
      }:
      mkDerivation {
        pname = "haskell-language-server";
-       version = "1.6.1.1";
-       sha256 = "03z650zk7ma0gsmb7mirzarwg0535kwmwyf0h8a89s8bqfcd5mxf";
+       version = "1.7.0.0";
+       sha256 = "1p5dr5j7vl86a4ig6y6cxf7rk8lswxsdxq9029sydghnyl3kaf3f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson-pretty async base base16-bytestring bytestring containers
          cryptohash-sha1 data-default directory extra filepath ghc ghcide
-         githash hie-bios hiedb hls-graph hls-plugin-api hslogger lsp
-         optparse-applicative optparse-simple process safe-exceptions
-         sqlite-simple text unordered-containers
+         githash hie-bios hiedb hls-graph hls-plugin-api lsp
+         optparse-applicative optparse-simple prettyprinter process
+         safe-exceptions sqlite-simple text unordered-containers
        ];
        executableHaskellDepends = [
          aeson async base base16-bytestring binary bytestring containers
          cryptohash-sha1 data-default deepseq directory extra filepath ghc
          ghc-boot-th ghc-paths ghcide gitrev hashable hie-bios hiedb
          hls-alternate-number-format-plugin hls-call-hierarchy-plugin
-         hls-class-plugin hls-eval-plugin hls-explicit-imports-plugin
-         hls-floskell-plugin hls-fourmolu-plugin hls-graph
-         hls-haddock-comments-plugin hls-hlint-plugin hls-module-name-plugin
-         hls-ormolu-plugin hls-plugin-api hls-pragmas-plugin
-         hls-qualify-imported-names-plugin hls-refine-imports-plugin
-         hls-retrie-plugin hls-selection-range-plugin hls-splice-plugin
-         hslogger lens lsp mtl optparse-applicative optparse-simple process
+         hls-change-type-signature-plugin hls-class-plugin hls-eval-plugin
+         hls-explicit-imports-plugin hls-floskell-plugin hls-fourmolu-plugin
+         hls-graph hls-haddock-comments-plugin hls-hlint-plugin
+         hls-module-name-plugin hls-ormolu-plugin hls-plugin-api
+         hls-pragmas-plugin hls-qualify-imported-names-plugin
+         hls-refine-imports-plugin hls-rename-plugin hls-retrie-plugin
+         hls-selection-range-plugin hls-splice-plugin lens lsp mtl
+         optparse-applicative optparse-simple prettyprinter process
          regex-tdfa safe-exceptions sqlite-simple stm temporary text
-         transformers unordered-containers
+         transformers unix unordered-containers
        ];
        testHaskellDepends = [
          aeson base bytestring containers data-default directory extra
          filepath ghcide hls-plugin-api hls-test-utils hspec-expectations
-         lens lens-aeson lsp-test lsp-types process text
+         lens lens-aeson lsp-test lsp-types prettyprinter process text
          unordered-containers
        ];
        testToolDepends = [ ghcide ];
···
      }:
      mkDerivation {
        pname = "hasql-th";
-       version = "0.4.0.11";
-       sha256 = "1dkx0r874qzn2kb8wimr1n75vmx70jx5ddi8088dlw5cxhj2v950";
+       version = "0.4.0.12";
+       sha256 = "0fcfm2d66f7hzzc9s73dd9dxcjsrr33c1q0v04j3zqm159kk69jd";
        libraryHaskellDepends = [
          base bytestring containers contravariant foldl hasql
          postgresql-syntax template-haskell template-haskell-compat-v0208
···
        license = lib.licenses.mit;
      }) {};
 
-  "hasql-th_0_4_0_12" = callPackage
+  "hasql-th_0_4_0_14" = callPackage
     ({ mkDerivation, base, bytestring, containers, contravariant, foldl
      , hasql, postgresql-syntax, template-haskell
      , template-haskell-compat-v0208, text, uuid, vector
      }:
      mkDerivation {
        pname = "hasql-th";
-       version = "0.4.0.12";
-       sha256 = "0fcfm2d66f7hzzc9s73dd9dxcjsrr33c1q0v04j3zqm159kk69jd";
+       version = "0.4.0.14";
+       sha256 = "0zskfsvxzilz6j3cd09hl6ixn3j9daksqjcb73pfm1f9hhrasa2a";
        libraryHaskellDepends = [
          base bytestring containers contravariant foldl hasql
          postgresql-syntax template-haskell template-haskell-compat-v0208
···
      }:
      mkDerivation {
        pname = "hasql-url";
-       version = "0.1.0.0";
-       sha256 = "12zsw4jag27g0bgxm9sp45bs2i7p5h42zs5avj01zlddpyhla0wx";
+       version = "0.2.0.0";
+       sha256 = "1f8vc7s031f33rkbzlmqac3h1g6aynj9z03x4lx19526q2d2r7ns";
        libraryHaskellDepends = [
          base bytestring hasql network-uri split
        ];
···
      }) {};
 
   "helic" = callPackage
-    ({ mkDerivation, aeson, base, chronos, containers, exon, gi-gdk
-     , gi-glib, gi-gtk, hostname, http-client, http-client-tls, incipit
-     , optparse-applicative, path, path-io, polysemy, polysemy-chronos
-     , polysemy-conc, polysemy-http, polysemy-log, polysemy-plugin
-     , polysemy-process, polysemy-test, polysemy-time, servant
-     , servant-client, servant-client-core, servant-server, table-layout
-     , tasty, template-haskell, terminal-size, torsor, transformers
-     , typed-process, unix, wai-extra, warp, yaml
+    ({ mkDerivation, aeson, base, chronos, containers, exon
+     , fast-logger, gi-gdk, gi-glib, gi-gtk, hostname, http-client
+     , http-client-tls, incipit, optparse-applicative, path, path-io
+     , polysemy, polysemy-chronos, polysemy-conc, polysemy-http
+     , polysemy-log, polysemy-plugin, polysemy-process, polysemy-test
+     , polysemy-time, servant, servant-client, servant-client-core
+     , servant-server, table-layout, tasty, template-haskell
+     , terminal-size, torsor, transformers, typed-process, unix
+     , wai-extra, warp, yaml
      }:
      mkDerivation {
        pname = "helic";
-       version = "0.5.1.0";
-       sha256 = "1gglcac10abszarmrgggrirf51jj0qcbp7gdqh93kghx1pqv4ldg";
+       version = "0.5.2.0";
+       sha256 = "0yklds711iya00fmp9l1kdyipdm8mrfssabqf8g7f55p1nnmn91g";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base chronos exon gi-gdk gi-glib gi-gtk hostname http-client
-         http-client-tls incipit optparse-applicative path path-io polysemy
-         polysemy-chronos polysemy-conc polysemy-http polysemy-log
-         polysemy-plugin polysemy-process polysemy-time servant
+         aeson base chronos exon fast-logger gi-gdk gi-glib gi-gtk hostname
+         http-client http-client-tls incipit optparse-applicative path
+         path-io polysemy polysemy-chronos polysemy-conc polysemy-http
+         polysemy-log polysemy-plugin polysemy-process polysemy-time servant
          servant-client servant-client-core servant-server table-layout
          template-haskell terminal-size transformers typed-process unix
          wai-extra warp yaml
···
        pname = "hiedb";
        version = "0.4.1.0";
        sha256 = "1389qmlga5rq8has02rn35pzag5wnfpx3w77r60mzl3b4pkpzi7i";
+       revision = "1";
+       editedCabalFile = "1ayy7xjbwfbdln1bqk9lpv2afc8kbzxyz9858gfafdd08kx0xmw1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
+  "hlint_3_4" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
+     , containers, cpphs, data-default, directory, extra, file-embed
+     , filepath, filepattern, ghc-lib-parser, ghc-lib-parser-ex
+     , hscolour, process, refact, text, transformers, uniplate
+     , unordered-containers, utf8-string, vector, yaml
+     }:
+     mkDerivation {
+       pname = "hlint";
+       version = "3.4";
+       sha256 = "15cfvch0yrzkl7qr87966amdsy05a7axvjc6wmw99ys9d5fn3z3n";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson ansi-terminal base bytestring cmdargs containers cpphs
+         data-default directory extra file-embed filepath filepattern
+         ghc-lib-parser ghc-lib-parser-ex hscolour process refact text
+         transformers uniplate unordered-containers utf8-string vector yaml
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Source code suggestions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ maralorn ];
+     }) {};
+
   "hlint-test" = callPackage
     ({ mkDerivation, base, hlint }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "hls-alternate-number-format-plugin";
-       version = "1.0.1.0";
-       sha256 = "1xr4rizv1k6dx32mnny55s33cngmvy0a52sswpk17fl4zx3bd0pp";
+       version = "1.1.0.0";
+       sha256 = "1s81p2jnln8v8ny13cf26d9925lfcyhs5di5xbh3p9645ngdiy9h";
        libraryHaskellDepends = [
          aeson base containers ghc-boot-th ghcide hie-compat hls-graph
          hls-plugin-api lens lsp mtl regex-tdfa syb text
···
      }:
      mkDerivation {
        pname = "hls-brittany-plugin";
-       version = "1.0.2.0";
-       sha256 = "0vxlhggmbrfmf81qgpxmrpsflmi32hafhy21dxain1as5hrnxw8g";
+       version = "1.0.2.1";
+       sha256 = "0f86iymcinbad9cpghi7965xhv4ky6kq4jqsn7nndq2jklwgrw7i";
        libraryHaskellDepends = [
          base brittany czipwith extra filepath ghc-boot-th ghc-exactprint
          ghcide hls-plugin-api lens lsp-types text transformers
···
      }:
      mkDerivation {
        pname = "hls-call-hierarchy-plugin";
-       version = "1.0.2.0";
-       sha256 = "0772kxdp6ww91a1b0c8lfxjlpvwr8smcf8ayvaxazw76hisxrrj5";
+       version = "1.0.3.0";
+       sha256 = "0yfl75d2ddkzrz3p1pn8spra0qssqazsqklan46zmagrv69yg5iv";
        libraryHaskellDepends = [
          aeson base bytestring containers extra ghc ghcide hiedb
          hls-plugin-api lens lsp sqlite-simple text unordered-containers
···
        license = lib.licenses.asl20;
      }) {};
 
+  "hls-change-type-signature-plugin" = callPackage
+    ({ mkDerivation, base, filepath, ghcide, hls-plugin-api
+     , hls-test-utils, lsp, lsp-types, QuickCheck, regex-tdfa, syb, text
+     , transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "hls-change-type-signature-plugin";
+       version = "1.0.1.0";
+       sha256 = "0wl4vgml491gkvzmsfj3nlwx18ywvrdwgwdkqjp0rwid0pidd6z8";
+       libraryHaskellDepends = [
+         base ghcide hls-plugin-api lsp-types regex-tdfa syb text
+         transformers unordered-containers
+       ];
+       testHaskellDepends = [
+         base filepath hls-test-utils lsp QuickCheck regex-tdfa text
+       ];
+       description = "Change a declarations type signature with a Code Action";
+       license = lib.licenses.asl20;
+     }) {};
+
   "hls-class-plugin" = callPackage
     ({ mkDerivation, aeson, base, containers, filepath, ghc
      , ghc-exactprint, ghcide, hls-plugin-api, hls-test-utils, lens, lsp
···
      }:
      mkDerivation {
        pname = "hls-class-plugin";
-       version = "1.0.2.0";
-       sha256 = "0drpxrazhwd228skgky7xdzcf22gi1pi2lby0dj0nzpzhrdl0pw0";
-       revision = "1";
-       editedCabalFile = "18x8k0gwpxv0vs4d8rbl5p0pjf75apb142i0p8vssbpvjwiwx33i";
+       version = "1.0.3.0";
+       sha256 = "0ad7ypw7d8waz3nq9p6m8l91rcibd2fzxxmdrpncwshiyrhazq3l";
        libraryHaskellDepends = [
          aeson base containers ghc ghc-exactprint ghcide hls-plugin-api lens
          lsp text transformers
···
      , ghc-paths, ghcide, hashable, hls-graph, hls-plugin-api
      , hls-test-utils, lens, lsp, lsp-types, megaparsec, mtl
      , parser-combinators, pretty-simple, QuickCheck, safe-exceptions
-     , temporary, text, time, transformers, unliftio
-     , unordered-containers
+     , text, time, transformers, unliftio, unordered-containers
      }:
      mkDerivation {
        pname = "hls-eval-plugin";
-       version = "1.2.1.0";
-       sha256 = "18xjq664b8aj199gd1sswa7gndwikch77v3p1c36yshfa0rviwi8";
+       version = "1.2.2.0";
+       sha256 = "17si94yzxz19hcddn57wf0npxc9m9vzb08b2gph7pkbxprsksb6g";
        libraryHaskellDepends = [
          aeson base containers data-default deepseq Diff directory dlist
          extra filepath ghc ghc-boot-th ghc-paths ghcide hashable hls-graph
          hls-plugin-api lens lsp lsp-types megaparsec mtl parser-combinators
-         pretty-simple QuickCheck safe-exceptions temporary text time
-         transformers unliftio unordered-containers
+         pretty-simple QuickCheck safe-exceptions text time transformers
+         unliftio unordered-containers
        ];
        testHaskellDepends = [
-         aeson base directory extra filepath hls-test-utils lens lsp-types
-         text
+         aeson base containers directory extra filepath hls-plugin-api
+         hls-test-utils lens lsp-types text
        ];
        description = "Eval plugin for Haskell Language Server";
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "hls-explicit-imports-plugin";
-       version = "1.0.2.0";
-       sha256 = "04v6sgzsjqk4qj586qzvfvq405z0zpc08xljxb12glmqghvi5xjg";
+       version = "1.1.0.0";
+       sha256 = "1r5cy59xk35d6smnrka42hxfa012h45nvsmlr1a1kbyac8ywzf6m";
        libraryHaskellDepends = [
          aeson base containers deepseq ghc ghcide hls-graph hls-plugin-api
          lsp text unordered-containers
···
      }:
      mkDerivation {
        pname = "hls-floskell-plugin";
-       version = "1.0.1.0";
-       sha256 = "1slzv2c5lzxprh8yhfk8iabmmlhh3sx97m393nrnwrjcbpzq0vai";
+       version = "1.0.1.1";
+       sha256 = "01c8xwfdgx5g5ipb366q0smjisyq1dfjz7scjfg5p3lyn0v555wb";
        libraryHaskellDepends = [
          base floskell ghcide hls-plugin-api lsp-types text transformers
        ];
···
      }) {};
 
   "hls-fourmolu-plugin" = callPackage
-    ({ mkDerivation, base, filepath, fourmolu, ghc, ghc-boot-th, ghcide
-     , hls-plugin-api, hls-test-utils, lens, lsp, lsp-test, text
+    ({ mkDerivation, aeson, base, containers, filepath, fourmolu, ghc
+     , ghc-boot-th, ghcide, hls-plugin-api, hls-test-utils, lens, lsp
+     , lsp-test, process-extras, text
      }:
      mkDerivation {
        pname = "hls-fourmolu-plugin";
-       version = "1.0.2.0";
-       sha256 = "0n9yk539wc046i6sx68gsbrc4jfmp1nsm2nir00q4sdcf7flcvff";
+       version = "1.0.3.0";
+       sha256 = "103rndxbmv72ghbh685766498j9rqnmgdwsrswk5nrf7afwd9x8w";
        libraryHaskellDepends = [
          base filepath fourmolu ghc ghc-boot-th ghcide hls-plugin-api lens
-         lsp text
+         lsp process-extras text
        ];
-       testHaskellDepends = [ base filepath hls-test-utils lsp-test ];
+       testHaskellDepends = [
+         aeson base containers filepath hls-plugin-api hls-test-utils
+         lsp-test
+       ];
+       testToolDepends = [ fourmolu ];
        description = "Integration with the Fourmolu code formatter";
        license = lib.licenses.asl20;
      }) {};
···
   "hls-graph" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, containers
      , deepseq, directory, exceptions, extra, filepath, focus, hashable
-     , js-dgtable, js-flot, js-jquery, list-t, primitive, stm
-     , stm-containers, time, transformers, unordered-containers
+     , hspec, hspec-discover, js-dgtable, js-flot, js-jquery, list-t
+     , primitive, stm, stm-containers, tasty, tasty-hspec, tasty-hunit
+     , tasty-rerun, text, time, transformers, unordered-containers
      }:
      mkDerivation {
        pname = "hls-graph";
-       version = "1.6.0.0";
-       sha256 = "0raz4gkfhxzbmg5rf65yp5p0i3mpd0rlraz90gwbvf5l1z9jlqml";
+       version = "1.7.0.0";
+       sha256 = "1mq1pvn5z8fnlsj9iqck05shm8fak9zf05mbcbrxb5jvq0a31ypd";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson async base bytestring containers deepseq directory exceptions
          extra filepath focus hashable js-dgtable js-flot js-jquery list-t
          primitive stm stm-containers time transformers unordered-containers
        ];
+       testHaskellDepends = [
+         base containers directory extra filepath hspec stm stm-containers
+         tasty tasty-hspec tasty-hunit tasty-rerun text
+       ];
+       testToolDepends = [ hspec-discover ];
        description = "Haskell Language Server internal graph API";
        license = lib.licenses.asl20;
      }) {};
···
        pname = "hls-haddock-comments-plugin";
        version = "1.0.1.0";
        sha256 = "1jlz6vg5ff2j2vba4yg8nymxfs7vmg5h3kzjhsj6bs2jn8kh722r";
+       revision = "1";
+       editedCabalFile = "004pi0hl1mf5njvadc45bkgahi97xdpf6pfafq1np5059ccyfd8d";
        libraryHaskellDepends = [
          base containers ghc ghc-exactprint ghcide hls-plugin-api lsp-types
          text unordered-containers
···
      , containers, data-default, deepseq, Diff, directory, extra
      , filepath, ghc, ghc-exactprint, ghc-lib-parser-ex, ghcide
      , hashable, hlint, hls-plugin-api, hls-test-utils, hslogger, lens
-     , lsp, lsp-types, regex-tdfa, stm, temporary, text, transformers
-     , unordered-containers
+     , lsp, lsp-types, refact, regex-tdfa, stm, temporary, text
+     , transformers, unordered-containers
      }:
      mkDerivation {
        pname = "hls-hlint-plugin";
-       version = "1.0.3.0";
-       sha256 = "0vzgsh6x8bjgi3l6nc9kfgbczxnd7fws5bmglac5khr0z042babb";
+       version = "1.0.4.0";
+       sha256 = "089pa1fg4ygc39a70g6x1ma1fci6jrkypg7hsmq4gf3h2rwiyvwy";
        libraryHaskellDepends = [
          aeson apply-refact base binary bytestring containers data-default
          deepseq Diff directory extra filepath ghc ghc-exactprint
          ghc-lib-parser-ex ghcide hashable hlint hls-plugin-api hslogger
-         lens lsp regex-tdfa stm temporary text transformers
+         lens lsp refact regex-tdfa stm temporary text transformers
          unordered-containers
        ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hls-module-name-plugin";
-       version = "1.0.1.0";
-       sha256 = "108p9j01d2s14akbwgwmpwb2a5r5d14vqzy6lw8n5cymgfdlza4a";
+       version = "1.0.2.0";
+       sha256 = "09548l8vmfq2y83agsr12w0x82drhmwa4bxpwby0mf466f4hj8da";
        libraryHaskellDepends = [
          aeson base directory filepath ghcide hls-plugin-api lsp text
          transformers unordered-containers
···
      }:
      mkDerivation {
        pname = "hls-ormolu-plugin";
-       version = "1.0.2.0";
-       sha256 = "1jbh16z4yzl3lx9q7pcrkfrmip6rifif3rirfn7dvyj1q7cf1fk4";
+       version = "1.0.2.1";
+       sha256 = "1if4gahvdayx1ar4wxi4mk074zxpx6wzkwdd64fnri4k5xb15sa7";
        libraryHaskellDepends = [
          base filepath ghc ghc-boot-th ghcide hls-plugin-api lens lsp ormolu
          text
···
   "hls-plugin-api" = callPackage
     ({ mkDerivation, aeson, base, containers, data-default
      , dependent-map, dependent-sum, Diff, dlist, extra, ghc, hashable
-     , hls-graph, hslogger, lens, lens-aeson, lsp, lsp-types
-     , opentelemetry, optparse-applicative, process, regex-tdfa, tasty
-     , tasty-hunit, tasty-rerun, text, transformers, unix
-     , unordered-containers
+     , hls-graph, lens, lens-aeson, lsp, lsp-types, opentelemetry
+     , optparse-applicative, process, regex-tdfa, tasty, tasty-hunit
+     , tasty-rerun, text, transformers, unix, unordered-containers
      }:
      mkDerivation {
        pname = "hls-plugin-api";
-       version = "1.3.0.0";
-       sha256 = "0dkpamqgw2icx6zns79cpzsnsr33qg0i3ix66hvcl5fhhp363g9m";
+       version = "1.4.0.0";
+       sha256 = "0yk2y6qw88vhww8z10d2kgn57wsarfnp6z1gmjl1ik2w96a8g3mv";
        libraryHaskellDepends = [
          aeson base containers data-default dependent-map dependent-sum Diff
-         dlist extra ghc hashable hls-graph hslogger lens lens-aeson lsp
+         dlist extra ghc hashable hls-graph lens lens-aeson lsp
          opentelemetry optparse-applicative process regex-tdfa text
          transformers unix unordered-containers
        ];
···
      }:
      mkDerivation {
        pname = "hls-pragmas-plugin";
-       version = "1.0.2.0";
-       sha256 = "0bmifvjhcvwhivnx6s971nidjdb2ichphp70pahx72ai24ffqqx9";
+       version = "1.0.2.1";
+       sha256 = "11l79214wz21v7plqf2wb6ac8bgw74fhql1p5cvkv8gr80hpb4jk";
        libraryHaskellDepends = [
          base containers extra fuzzy ghc ghcide hls-plugin-api lens lsp text
          transformers unordered-containers
···
        pname = "hls-qualify-imported-names-plugin";
        version = "1.0.1.0";
        sha256 = "0h456cq3qvksrkzfzpq2qsabsl3vpg4gh2mwyxc39xh4qm7ifban";
+       revision = "1";
+       editedCabalFile = "0pb9fgpbv24726n250rkb33gx3f3xcaxmv1qqh12q4sz181qn4mb";
        libraryHaskellDepends = [
          aeson base containers deepseq dlist ghc ghcide hls-graph
          hls-plugin-api lsp text transformers unordered-containers
···
      }:
      mkDerivation {
        pname = "hls-refine-imports-plugin";
-       version = "1.0.1.0";
-       sha256 = "10q5yjpny5aah245ivazqn2h05ak428qc9arpzlg5ks2n4n293lf";
+       version = "1.0.2.0";
+       sha256 = "01hgz66dm6rpk7fp6b2byzvnaan3snvimkicl67c6qxla9dpxcjn";
        libraryHaskellDepends = [
          aeson base containers deepseq ghc ghcide
          hls-explicit-imports-plugin hls-graph hls-plugin-api lsp text
···
      }) {};
 
   "hls-rename-plugin" = callPackage
-    ({ mkDerivation, base, containers, extra, filepath, ghc
-     , ghc-exactprint, ghcide, hiedb, hls-plugin-api, hls-test-utils
-     , lsp, lsp-types, syb, text, transformers
+    ({ mkDerivation, aeson, base, containers, extra, filepath, ghc
+     , ghc-exactprint, ghcide, hashable, hiedb, hls-plugin-api
+     , hls-test-utils, lsp, lsp-types, mod, syb, text, transformers
+     , unordered-containers
      }:
      mkDerivation {
        pname = "hls-rename-plugin";
-       version = "1.0.0.1";
-       sha256 = "04l2w3x60ayxa9a6cdmscrfvyx9fsnbl4q05m8f0s1s18zlgjf86";
+       version = "1.0.0.2";
+       sha256 = "1cqcyyh4ywxwl2wppdacp2y6hpbl5534vq8xw2ih489qczcg6s78";
        libraryHaskellDepends = [
-         base containers extra ghc ghc-exactprint ghcide hiedb
-         hls-plugin-api lsp lsp-types syb text transformers
+         base containers extra ghc ghc-exactprint ghcide hashable hiedb
+         hls-plugin-api lsp lsp-types mod syb text transformers
+         unordered-containers
        ];
-       testHaskellDepends = [ base filepath hls-test-utils ];
+       testHaskellDepends = [
+         aeson base containers filepath hls-plugin-api hls-test-utils
+       ];
        description = "Rename plugin for Haskell Language Server";
        license = lib.licenses.asl20;
      }) {};
···
      }:
      mkDerivation {
        pname = "hls-retrie-plugin";
-       version = "1.0.2.0";
-       sha256 = "0w41di7rqy8xrcaavzlfhai73yw0whmnyqxhyfjwx93y1sy1l6zg";
+       version = "1.0.2.1";
+       sha256 = "1vl7kdw8sm9r5q35lnihq0r98wd2s3mm76c7wp0cwd55qdkaf7qv";
        libraryHaskellDepends = [
          aeson base bytestring containers deepseq directory extra ghc ghcide
          hashable hls-plugin-api lsp lsp-types retrie safe-exceptions stm
···
        pname = "hls-selection-range-plugin";
        version = "1.0.0.0";
        sha256 = "1pfgxz7nyqr8gaxxv7nc0d4rpfc4rbgdkafy1fpgcsbkqx9llkn0";
+       revision = "1";
+       editedCabalFile = "1njq2p1z9z5gy0fxgbp81q4syqw3hx1b5151g93qhhla9d0cr7nv";
        libraryHaskellDepends = [
          aeson base containers extra ghcide hls-plugin-api lsp mtl
          semigroupoids text transformers
···
        pname = "hls-splice-plugin";
        version = "1.0.1.0";
        sha256 = "07v4rgss140vfc4xqibccimm48ys4awz7yficr0wf440p6i83qdc";
+       revision = "1";
+       editedCabalFile = "15hr2vc1r4zxf4z26byax95cdqhl1733fna16lifrdj15xkwxs3r";
        libraryHaskellDepends = [
          aeson base containers dlist extra foldl ghc ghc-exactprint ghcide
          hls-plugin-api lens lsp retrie syb text transformers unliftio-core
···
      }:
      mkDerivation {
        pname = "hls-stylish-haskell-plugin";
-       version = "1.0.1.0";
-       sha256 = "1f9g113xrb167cpdjifd2zp8ps1w2apvkghdiagc9rzw1fl0l7l4";
+       version = "1.0.1.1";
+       sha256 = "1k9bv31226zgy5aqxzzj7npph2ff0r5bx692q5n26lpil2ivq6sn";
        libraryHaskellDepends = [
          base directory filepath ghc ghc-boot-th ghcide hls-plugin-api
          lsp-types stylish-haskell text
···
      }:
      mkDerivation {
        pname = "hls-tactics-plugin";
-       version = "1.6.1.0";
-       sha256 = "15ynxlafrs0hss5qcn4aj8iip8iy631hfgqql0irqskvf3x5yxlx";
+       version = "1.6.2.0";
+       sha256 = "07qh9sz3rbqflfryxaj7y8vjmv388jdsmaxvz5z0xfq895yk968p";
        libraryHaskellDepends = [
          aeson base containers deepseq directory extra filepath fingertree
          generic-lens ghc ghc-boot-th ghc-exactprint ghc-source-gen ghcide
···
   "hls-test-utils" = callPackage
     ({ mkDerivation, aeson, async, base, blaze-markup, bytestring
      , containers, data-default, directory, extra, filepath, ghcide
-     , hls-graph, hls-plugin-api, hspec, hspec-core, lens, lsp, lsp-test
-     , lsp-types, tasty, tasty-expected-failure, tasty-golden
-     , tasty-hunit, tasty-rerun, temporary, text, unordered-containers
+     , hls-graph, hls-plugin-api, lens, lsp, lsp-test, lsp-types, tasty
+     , tasty-expected-failure, tasty-golden, tasty-hunit, tasty-rerun
+     , temporary, text, unordered-containers
      }:
      mkDerivation {
        pname = "hls-test-utils";
-       version = "1.2.0.0";
-       sha256 = "1y3g101n7z78f5shfqfklg5zgl8gpkic0dwvpr5072dq1vvpfdvf";
+       version = "1.3.0.0";
+       sha256 = "1qm3lna4jy658bmbr6gpjq2gmcz03rdz535gilxycbjkxl2z3hkq";
        libraryHaskellDepends = [
          aeson async base blaze-markup bytestring containers data-default
-         directory extra filepath ghcide hls-graph hls-plugin-api hspec
-         hspec-core lens lsp lsp-test lsp-types tasty tasty-expected-failure
-         tasty-golden tasty-hunit tasty-rerun temporary text
-         unordered-containers
+         directory extra filepath ghcide hls-graph hls-plugin-api lens lsp
+         lsp-test lsp-types tasty tasty-expected-failure tasty-golden
+         tasty-hunit tasty-rerun temporary text unordered-containers
        ];
        description = "Utilities used in the tests of Haskell Language Server";
        license = lib.licenses.asl20;
···
        license = lib.licenses.mit;
      }) {};
 
+  "hpack_0_35_0" = callPackage
+    ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
+     , containers, cryptonite, deepseq, directory, filepath, Glob, hspec
+     , hspec-discover, http-client, http-client-tls, http-types, HUnit
+     , infer-license, interpolate, mockery, pretty, QuickCheck
+     , scientific, template-haskell, temporary, text, transformers
+     , unordered-containers, vector, yaml
+     }:
+     mkDerivation {
+       pname = "hpack";
+       version = "0.35.0";
+       sha256 = "1cii4bdn4rm2l3yw9vsv4ygn61zmalaa282iqg9rihys90nvrgf6";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bifunctors bytestring Cabal containers cryptonite
+         deepseq directory filepath Glob http-client http-client-tls
+         http-types infer-license pretty scientific text transformers
+         unordered-containers vector yaml
+       ];
+       executableHaskellDepends = [
+         aeson base bifunctors bytestring Cabal containers cryptonite
+         deepseq directory filepath Glob http-client http-client-tls
+         http-types infer-license pretty scientific text transformers
+         unordered-containers vector yaml
+       ];
+       testHaskellDepends = [
+         aeson base bifunctors bytestring Cabal containers cryptonite
+         deepseq directory filepath Glob hspec http-client http-client-tls
+         http-types HUnit infer-license interpolate mockery pretty
+         QuickCheck scientific template-haskell temporary text transformers
+         unordered-containers vector yaml
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A modern format for Haskell packages";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hpack-convert" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, base-compat, bytestring
      , Cabal, containers, deepseq, directory, filepath, Glob, hspec
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "hpack-dhall_0_5_5" = callPackage
+  "hpack-dhall_0_5_7" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal
      , dhall, dhall-json, Diff, directory, filepath, hpack, megaparsec
      , microlens, optparse-applicative, prettyprinter, tasty
···
      }:
      mkDerivation {
        pname = "hpack-dhall";
-       version = "0.5.5";
-       sha256 = "1256vqqncgir0ir7i0vnvr7v5jkyx5ggng8gyi4qsqs8lmqn11r3";
+       version = "0.5.7";
+       sha256 = "1hwq3painl4ix7pldkzi5a8zakh9f67kcyabfbdky8b49dc5703r";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hs-opentelemetry-api";
-       version = "0.0.3.3";
-       sha256 = "0hrlz77p5w57ax4jml5c415qb1bfh8zi357xvnb0bin7g5a00fn8";
+       version = "0.0.3.4";
+       sha256 = "0qg5kaybxax632nbj6qjrn02j1c954kpw5xv3yqsysdqqcqxw6bg";
        libraryHaskellDepends = [
          async attoparsec base binary bytestring charset clock containers
          ghc-prim hashable http-types memory mtl template-haskell text
···
      }:
      mkDerivation {
        pname = "hs-opentelemetry-instrumentation-wai";
-       version = "0.0.1.2";
-       sha256 = "1yxy49cacldbic67ic35ym48zd0c1cwx1cjh6l0fxn26yvjp1i68";
+       version = "0.0.1.3";
+       sha256 = "1dczyw9w9pahrrj0q2qcnkx7kc46k7gqrrpbspdc0rc09idk33jx";
        libraryHaskellDepends = [
          base bytestring hs-opentelemetry-api http-types iproute network
          text vault wai
···
     ({ mkDerivation, base, hsp, jmacro, mtl, text, wl-pprint-text }:
      mkDerivation {
        pname = "hsx-jmacro";
-       version = "7.3.8.1";
-       sha256 = "0ndgy5vf5rwgwqya75ny5vbr7hfqwjrdgfgpwf5410bk0603v47i";
+       version = "7.3.8.2";
+       sha256 = "0zb6mjky88qn918vaqbwjszjb6zczb4kqpnw3p222z44if3xpzsq";
        libraryHaskellDepends = [
          base hsp jmacro mtl text wl-pprint-text
        ];
···
      }) {};
 
   "hyperloglog" = callPackage
-    ({ mkDerivation, approximate, base, binary, bits, bytes, cereal
-     , cereal-vector, comonad, deepseq, distributive, hashable, lens
-     , reflection, semigroupoids, semigroups, siphash, tagged, vector
-     }:
-     mkDerivation {
-       pname = "hyperloglog";
-       version = "0.4.5";
-       sha256 = "0v2zw0p104gbydj6hp2cxa2s4b85pq4srcspr582aqj38bs7spfz";
-       libraryHaskellDepends = [
-         approximate base binary bits bytes cereal cereal-vector comonad
-         deepseq distributive hashable lens reflection semigroupoids
-         semigroups siphash tagged vector
-       ];
-       description = "An approximate streaming (constant space) unique object counter";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "hyperloglog_0_4_6" = callPackage
     ({ mkDerivation, approximate, base, binary, bits, bytes, bytestring
      , cereal, cereal-vector, comonad, cpu, deepseq, distributive
      , hashable, lens, reflection, semigroupoids, semigroups, tagged
···
        ];
        description = "An approximate streaming (constant space) unique object counter";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hyperloglogplus" = callPackage
···
      }:
      mkDerivation {
        pname = "implicit-hie";
-       version = "0.1.2.6";
-       sha256 = "1j2q1mqxfgcb8r6388xanmp5i1sdh6w52s08nd94g5lpg93mjz2q";
+       version = "0.1.2.7";
+       sha256 = "0yb457n26455kbq6kv8g48q66pmmaxcpikmpg9gm00sd6adgq6gl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "io-streams-haproxy";
        version = "1.0.1.0";
        sha256 = "1dcn5hd4fiwyq7m01r6fi93vfvygca5s6mz87c78m0zyj29clkmp";
-       revision = "3";
-       editedCabalFile = "02k9halblgnynlm781ahc81yxla8z7cck1gikm8555v78rf5hv7x";
+       revision = "5";
+       editedCabalFile = "073aciql0czvpaiwh9mpljcd1j2a8p5ka5awsw1j3dh7bdyg2mp7";
        libraryHaskellDepends = [
          attoparsec base bytestring io-streams network transformers
        ];
···
        pname = "ip";
        version = "1.7.4";
        sha256 = "1hvqgah86z2saizhjpq2352x2ncxjsshvzj66bmij3yk6y107yfs";
+       revision = "1";
+       editedCabalFile = "09yrwzklzbfvh5x4j7k4vx7a49kndfz9d8kjkfvwi3frqzhr209m";
        libraryHaskellDepends = [
          aeson attoparsec base bytebuild byteslice bytesmith bytestring
          deepseq hashable natural-arithmetic primitive text text-short
···
        ];
        description = "Intervals";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ivar-simple" = callPackage
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "Indexed monads";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ix-shapable" = callPackage
···
      }:
      mkDerivation {
        pname = "ixset";
-       version = "1.1.1.1";
-       sha256 = "1d3h53sq8i8azzr71yi4h5zma2bb2f623gpfw25x2kd4slhpkrgf";
+       version = "1.1.1.2";
+       sha256 = "15dgh9lgjqgn0483p98q21ym1mrwi5h7ygdjxf48aap1d20x6swp";
        libraryHaskellDepends = [
          base containers safecopy syb syb-with-class template-haskell
        ];
···
      }:
      mkDerivation {
        pname = "jmacro";
-       version = "0.6.17";
-       sha256 = "14vmnaqr3lhcj7y5rj4jgm2w89kkznfksy53pinmc1xq1bd8b7px";
+       version = "0.6.17.1";
+       sha256 = "17z39w888nrq0jfzi74z1wnswzmcyi2x6h2p2nnmhyjsgvpjkcxa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "keter";
-       version = "1.8.4";
-       sha256 = "10p8hc1jfzkg3s8shazkip95i6r5a8gyiz6m1khl7myvb05i21gc";
+       version = "1.9";
+       sha256 = "00mgh6447p0gsvm7agy1i9a874afirirx2a7qdqnbw1m14j3mzfl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Store of values of arbitrary types";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "keycloak-hs" = callPackage
···
      }:
      mkDerivation {
        pname = "koji-tool";
-       version = "0.8.2";
-       sha256 = "0hhpw8v09alicymbndl6lpflasmzchrf8zg1l4gqd8j9sj2rrzqg";
+       version = "0.8.3";
+       sha256 = "17xd1755yr2acf6brwbxn3yzbndv982s7jgxbj9dmd7my6v1d9i2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "lsfrom";
-       version = "0.1";
-       sha256 = "04cv4x88r10b9zkfiy1kclq3dm79akg1p16djfad8h5x988c7bq1";
+       version = "0.1.1.1";
+       sha256 = "1vm80k8gsh4k7937i02wv4dk2s173c9wvgiilc1am3ddp7x7ms1h";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          base filepath simple-cmd simple-cmd-args
        ];
        testHaskellDepends = [ base directory filepath simple-cmd ];
-       description = "List dir files starting from a specific name";
+       description = "List directory files starting from a specific name";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
        pname = "map-syntax";
        version = "0.3";
        sha256 = "0b3ddi998saw5gi5r4bjbpid03rxlifn08zv15wf0b90ambhcc4k";
-       revision = "3";
-       editedCabalFile = "19p79gjwlpgx210zlc9625vwp6mjmnb9mvxaz1h5zmgir8dwb4lv";
+       revision = "4";
+       editedCabalFile = "09sr3lzgkqs59vnwsimqgv098h3hj4srr2avza3z05gfkvxqj8yw";
        libraryHaskellDepends = [ base containers mtl ];
        testHaskellDepends = [
          base containers deepseq hspec HUnit mtl QuickCheck transformers
···
     ({ mkDerivation, base, tidal }:
      mkDerivation {
        pname = "maquinitas-tidal";
-       version = "0.2.4";
-       sha256 = "0apr5qkir3b6mnczi50lf3p349p1q3bl1sn4yg9dls2n3m147mf7";
+       version = "0.2.5";
+       sha256 = "1jqa471r7r3my32lrjcrfc35259kj7afp1jgj8jr3r62dd8ckq63";
        libraryHaskellDepends = [ base tidal ];
        description = "library for MIDI control of hardware";
        license = lib.licenses.mit;
···
        ];
        description = "A GUI library for writing native Haskell applications";
        license = lib.licenses.bsd3;
+     }) {inherit (pkgs) glew;};
+
+  "monomer_1_4_0_0" = callPackage
+    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
+     , bytestring-to-vector, c2hs, containers, data-default, exceptions
+     , extra, formatting, glew, hspec, http-client, JuicyPixels, lens
+     , mtl, nanovg, OpenGLRaw, process, random, sdl2, stm, text
+     , text-show, time, transformers, vector, websockets, wreq, wuss
+     }:
+     mkDerivation {
+       pname = "monomer";
+       version = "1.4.0.0";
+       sha256 = "104j89l1c39yl9sqfv1nsq7c3p00v0h28kvrmym46b5w1hd86xxr";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async attoparsec base bytestring bytestring-to-vector containers
+         data-default exceptions extra formatting http-client JuicyPixels
+         lens mtl nanovg OpenGLRaw process sdl2 stm text text-show time
+         transformers vector wreq
+       ];
+       librarySystemDepends = [ glew ];
+       libraryToolDepends = [ c2hs ];
+       executableHaskellDepends = [
+         aeson async attoparsec base bytestring bytestring-to-vector
+         containers data-default exceptions extra formatting http-client
+         JuicyPixels lens mtl nanovg OpenGLRaw process random sdl2 stm text
+         text-show time transformers vector websockets wreq wuss
+       ];
+       testHaskellDepends = [
+         async attoparsec base bytestring bytestring-to-vector containers
+         data-default exceptions extra formatting hspec http-client
+         JuicyPixels lens mtl nanovg OpenGLRaw process sdl2 stm text
+         text-show time transformers vector wreq
+       ];
+       description = "A GUI library for writing native Haskell applications";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) glew;};
 
   "monomorphic" = callPackage
···
      }:
      mkDerivation {
        pname = "org-mode";
-       version = "2.0.0";
-       sha256 = "17yn9si0mxyydjgv40q6rc5nw579kswlx69ycyinhdx0q34ds7rl";
+       version = "2.0.1";
+       sha256 = "0g22gjy7l6c28j60vbhazgcl0da58mml307qsp4zac4j4nshv7y2";
        libraryHaskellDepends = [
          base containers filepath hashable megaparsec parser-combinators
          text time
···
      }:
      mkDerivation {
        pname = "org-mode-lucid";
-       version = "1.6.1";
-       sha256 = "0fkwwwrmfq22g1yak9srmlbq5yixf4kdwfapq0dyr8f3pqaglf1v";
+       version = "1.6.2";
+       sha256 = "0qz8s63m2l0aff23fgdn97xxswbn3ah3m4rx9snfi5cscsrzsb8h";
        libraryHaskellDepends = [
          base containers hashable lucid org-mode text
        ];
···
      }:
      mkDerivation {
        pname = "pcf-font";
-       version = "0.2.2.0";
-       sha256 = "1vwqy2zkj0yb0b7hx3hrcfdcg46j67sv9l8ljik8wrm7811d0rwa";
+       version = "0.2.2.1";
+       sha256 = "1gzlbdyhcrf7ap6zjd0fvkfwyakvb805198hpb9a86hrs5bih9mj";
        libraryHaskellDepends = [
          base binary bytestring containers vector zlib
        ];
···
      }:
      mkDerivation {
        pname = "pcre2";
-       version = "2.1.0.1";
-       sha256 = "06fj8p49whxixphncmzm0c85wzqrsmg59zbb423qnqqmcwjwy2qf";
+       version = "2.1.1";
+       sha256 = "07ls9vxj5l8wvrj75wvyrq6qsz7fz0pamx92ik50cpl71p76lc92";
        libraryHaskellDepends = [
          base containers microlens mtl template-haskell text
        ];
···
      }:
      mkDerivation {
        pname = "persistent-typed-db";
-       version = "0.1.0.5";
-       sha256 = "0xqvaypl987br15pymky9qa1z62sfa32kmcgpvnl8zpgdjsa17nc";
+       version = "0.1.0.6";
+       sha256 = "1hvja9yh40nqifvy0fsamdfj3f9ps85g187c7m3hg2yqz4w8pm05";
        libraryHaskellDepends = [
          aeson base bytestring conduit http-api-data monad-logger
          path-pieces persistent resource-pool resourcet template-haskell
···
     ({ mkDerivation, base, subG }:
      mkDerivation {
        pname = "phonetic-languages-constraints-array";
-       version = "0.1.1.0";
-       sha256 = "1c5n04zkfhws6ciilbkya4fyr3qc2yszmqrbb7pk3jcjnv2xp32b";
+       version = "0.1.2.0";
+       sha256 = "1s28pipyijz13sn6wni9v850w8c6n6rkiqmavhddfnichwp3gq55";
        libraryHaskellDepends = [ base subG ];
        description = "Constraints to filter the needed permutations";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, filters-basic, mmsyn2-array }:
      mkDerivation {
        pname = "phonetic-languages-filters-array";
-       version = "0.3.0.0";
-       sha256 = "0g1nyab2cagppwj75vr2fj0yd9g3hs1qdkb2grj14j13bvaqbi7p";
+       version = "0.4.0.0";
+       sha256 = "0rkgwf9v98vdflhkcfn7s0in8dw69rh2dcv8n9lvpjd0ccmlvil8";
        libraryHaskellDepends = [ base filters-basic mmsyn2-array ];
        description = "Allows to change the structure of the function output";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-examples-array";
-       version = "0.17.1.0";
-       sha256 = "00lb3h4b0yd3ra0i6g64r8vfn2cyazrqai51arfprihyj31zm9kq";
+       version = "0.18.0.2";
+       sha256 = "0m79iv739cakgpfbixg613fhwjnvy4nidqvfrvqgq53wn4x9pdm3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "phonetic-languages-simplified-examples-common" = callPackage
-    ({ mkDerivation, base, heaps, phonetic-languages-constraints-array
-     , phonetic-languages-ukrainian-array
-     }:
+    ({ mkDerivation, base, heaps, phonetic-languages-ukrainian-array }:
      mkDerivation {
        pname = "phonetic-languages-simplified-examples-common";
-       version = "0.4.4.0";
-       sha256 = "1y5nrr23blxm08s62q58aq0yiifxgds9lf2wf45zz11w1z16ff1n";
+       version = "0.4.6.0";
+       sha256 = "13i8pq52bfmxvidvykn1hcy9yv2i8yni76mcnbmfwdbd1sy615pn";
        libraryHaskellDepends = [
-         base heaps phonetic-languages-constraints-array
-         phonetic-languages-ukrainian-array
+         base heaps phonetic-languages-ukrainian-array
        ];
        description = "Some commonly used by phonetic-languages-simplified* series functions";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "phonetic-languages-simplified-generalized-examples-array" = callPackage
-    ({ mkDerivation, base, cli-arguments, heaps, mmsyn2-array, mmsyn3
-     , parallel, phonetic-languages-constraints-array
+    ({ mkDerivation, base, cli-arguments, foldable-ix, heaps
+     , mmsyn2-array, mmsyn3, parallel
+     , phonetic-languages-constraints-array
      , phonetic-languages-filters-array
      , phonetic-languages-permutations-array
      , phonetic-languages-phonetics-basics, phonetic-languages-plus
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-array";
-       version = "0.15.0.0";
-       sha256 = "1rayhhyvqskxw374jrl5h92lhx0n3k3wda7vw4wkgw3kbargwm7q";
+       version = "0.16.0.0";
+       sha256 = "16ia1kd217hy0wpdjd60l1qdz2ivcm1n0sncp106x4dksy4xc1pv";
        libraryHaskellDepends = [
-         base cli-arguments heaps mmsyn2-array mmsyn3 parallel
+         base cli-arguments foldable-ix heaps mmsyn2-array mmsyn3 parallel
          phonetic-languages-constraints-array
          phonetic-languages-filters-array
          phonetic-languages-permutations-array
···
      }) {};
 
   "polysemy-RandomFu" = callPackage
-    ({ mkDerivation, base, hspec, hspec-discover, polysemy
-     , polysemy-plugin, polysemy-zoo, random-fu, random-source, text
-     , vector
+    ({ mkDerivation, base, hspec, hspec-discover, mtl, polysemy
+     , polysemy-plugin, polysemy-zoo, random, random-fu, random-source
+     , rvar, text, vector
      }:
      mkDerivation {
        pname = "polysemy-RandomFu";
-       version = "0.4.4.1";
-       sha256 = "1zw8n16dm2l8rwrf014kb9jhp3q4a719bp8p08s4fnlksqkf88vl";
+       version = "0.5.0.0";
+       sha256 = "0zjywc9m7y56kzxvzayq4psjz6zip1x40cpjkvw39i5p2jkycc4c";
        libraryHaskellDepends = [
-         base polysemy polysemy-plugin polysemy-zoo random-fu random-source
+         base mtl polysemy polysemy-plugin polysemy-zoo random random-fu
+         random-source rvar
        ];
        testHaskellDepends = [
-         base hspec polysemy polysemy-plugin polysemy-zoo random-fu
-         random-source text vector
+         base hspec mtl polysemy polysemy-plugin polysemy-zoo random
+         random-fu random-source text vector
        ];
        testToolDepends = [ hspec-discover ];
        description = "Experimental, RandomFu effect and interpreters for polysemy";
···
      }:
      mkDerivation {
        pname = "polysemy-conc";
-       version = "0.7.0.0";
-       sha256 = "0jr5wh0sxbymz4p9x2p86cm9djr8bybss747xx9c778va0vgcncg";
+       version = "0.8.0.1";
+       sha256 = "0l1hgv9xlax5ycp66j5asfhfi9jyfcwvd9z132pbx8dyj4ikzp8y";
        libraryHaskellDepends = [
          async base containers incipit-core polysemy polysemy-resume
          polysemy-time stm stm-chans torsor unagi-chan unix
···
     ({ mkDerivation, base, incipit-core, path, path-io, polysemy
      , polysemy-conc, polysemy-plugin, polysemy-resume, polysemy-test
      , polysemy-time, posix-pty, process, stm-chans, tasty
-     , typed-process, unix
+     , tasty-expected-failure, typed-process, unix
      }:
      mkDerivation {
        pname = "polysemy-process";
-       version = "0.7.0.0";
-       sha256 = "0g1rmii4jnffl2f4ziibw62nkgzl92wf4pvq0fvzwkm01rpm9frz";
+       version = "0.8.0.1";
+       sha256 = "0ayn6l2c6009wrxc4rya6dc8185wp6krdck8mbbasrlvah3in3cs";
        libraryHaskellDepends = [
          base incipit-core path path-io polysemy polysemy-conc
-         polysemy-resume posix-pty process stm-chans typed-process unix
+         polysemy-resume polysemy-time posix-pty process stm-chans
+         typed-process unix
        ];
        testHaskellDepends = [
          base incipit-core polysemy polysemy-conc polysemy-plugin
-         polysemy-resume polysemy-test polysemy-time tasty typed-process
+         polysemy-resume polysemy-test polysemy-time tasty
+         tasty-expected-failure typed-process
        ];
        description = "Polysemy Effects for System Processes";
        license = "BSD-2-Clause-Patent";
···
        ];
        description = "Polysemy error tracking";
        license = "BSD-2-Clause-Patent";
+     }) {};
+
+  "polysemy-scoped-fs" = callPackage
+    ({ mkDerivation, base, bytestring, directory, doctest, extra, path
+     , polysemy, polysemy-fs, polysemy-path, polysemy-plugin, text
+     }:
+     mkDerivation {
+       pname = "polysemy-scoped-fs";
+       version = "0.1.0.0";
+       sha256 = "08mj5q8rfbhyd7ns4vf696cqvm0792f5dv3x1w0ci3spl2m7nhdi";
+       libraryHaskellDepends = [
+         base bytestring directory doctest extra path polysemy polysemy-fs
+         polysemy-path polysemy-plugin text
+       ];
+       testHaskellDepends = [
+         base bytestring directory doctest extra path polysemy polysemy-fs
+         polysemy-path polysemy-plugin text
+       ];
+       description = "Well-typed filesystem operation effects";
+       license = lib.licenses.agpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "polysemy-several" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "postgresql-syntax_0_4_1" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, hashable
+     , headed-megaparsec, hedgehog, megaparsec, parser-combinators
+     , QuickCheck, quickcheck-instances, rerebase, tasty, tasty-hunit
+     , tasty-quickcheck, text, text-builder, unordered-containers
+     }:
+     mkDerivation {
+       pname = "postgresql-syntax";
+       version = "0.4.1";
+       sha256 = "1ls3jjgbvdy0x3110lgjd3icas187qyd31cwvi858l6ayhwf9kck";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive hashable headed-megaparsec
+         megaparsec parser-combinators text text-builder
+         unordered-containers
+       ];
+       testHaskellDepends = [
+         hedgehog QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       description = "PostgreSQL AST parsing and rendering";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "postgresql-transactional" = callPackage
     ({ mkDerivation, base, monad-control, mtl, postgresql-simple }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "powerdns";
-       version = "0.4.0";
-       sha256 = "0gcf04naa9ai4f6v7ycakwmdz379dqrr3nl0ry1pnqck835p629a";
+       version = "0.4.1";
+       sha256 = "1ss88q1lndjvmy7bp2jxh7qbh6z57kl1q5zcv4kzjampajf1fjbi";
        revision = "1";
-       editedCabalFile = "1pf6f09kdawn17nrjn221xr40g66wa282r65521y4mdmlm6yrfd0";
+       editedCabalFile = "08n8l7629ci2xksjihqwrag0gcj0cdhaj94awmybd454j4idy5c1";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive containers
          deepseq hashable servant servant-client servant-client-core text
          time
        ];
        testHaskellDepends = [
-         base http-client servant-client servant-client-core tasty
+         base http-client servant servant-client servant-client-core tasty
          tasty-hunit
        ];
        description = "PowerDNS API bindings for api/v1";
···
      }:
      mkDerivation {
        pname = "procex";
-       version = "0.3.1";
-       sha256 = "16f91ic12wldf59dabdca76bdcvq5r1alf05bai060dby5qqj2qj";
+       version = "0.3.2";
+       sha256 = "0962i86fdlgrzrzq6sp1v5hpkp1vsrsacpnalxvsz1nc81pi14qj";
        libraryHaskellDepends = [
          async base bytestring containers deepseq unix utf8-string
        ];
···
        libraryHaskellDepends = [ base category ];
        description = "Product category";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "product-isomorphic" = callPackage
···
      }:
      mkDerivation {
        pname = "ptera-th";
-       version = "0.3.0.0";
-       sha256 = "0w5kr7cp0kcxh1cmqb38waxci81i9ccqn42kvhkrkzf35pnkn0m4";
+       version = "0.4.0.0";
+       sha256 = "00rvc6y3wnxsr3ybxd3wmywgcwsajjh0g40magnlfzkgdnih9qg2";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          array base containers enummapset-th ghc-prim membership ptera
···
        benchmarkHaskellDepends = [ gauge rerebase ];
        description = "Pointer poking action construction and composition toolkit";
        license = lib.licenses.mit;
+     }) {};
+
+  "ptr-poker_0_1_2_8" = callPackage
+    ({ mkDerivation, base, bytestring, gauge, hedgehog, numeric-limits
+     , rerebase, scientific, text
+     }:
+     mkDerivation {
+       pname = "ptr-poker";
+       version = "0.1.2.8";
+       sha256 = "10bbfw0jdzvds4j6qcgppn4l7xflqa2578w6sqmz807mwr563f8c";
+       libraryHaskellDepends = [ base bytestring scientific text ];
+       testHaskellDepends = [ hedgehog numeric-limits rerebase ];
+       benchmarkHaskellDepends = [ gauge rerebase ];
+       description = "Pointer poking action construction and composition toolkit";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ptrdiff" = callPackage
···
      , fsnotify, gitrev, Glob, happy, haskeline, hspec, hspec-discover
      , http-types, HUnit, language-javascript, lifted-async, lifted-base
      , memory, microlens, microlens-platform, monad-control
-     , monad-logger, mtl, network, optparse-applicative, parallel
-     , parsec, pattern-arrows, process, protolude, purescript-cst
-     , QuickCheck, regex-base, regex-tdfa, safe, scientific, semialign
-     , semigroups, serialise, sourcemap, split, stm, stringsearch, syb
-     , text, these, time, transformers, transformers-base
-     , transformers-compat, unordered-containers, utf8-string, vector
-     , wai, wai-websockets, warp, websockets
+     , monad-logger, monoidal-containers, mtl, network
+     , optparse-applicative, parallel, parsec, pattern-arrows, process
+     , protolude, QuickCheck, regex-base, regex-tdfa, safe, scientific
+     , semialign, semigroups, serialise, sourcemap, split, stm
+     , stringsearch, syb, text, these, time, transformers
+     , transformers-base, transformers-compat, unordered-containers
+     , utf8-string, vector
      }:
      mkDerivation {
        pname = "purescript";
-       version = "0.14.9";
-       sha256 = "13canh915v668ii58y880b6zgzga3qmxxiblljs9qsdpwx1q7yzd";
+       version = "0.15.0";
+       sha256 = "0md1rkm7w6yn45i4igwqpvb82p491ai1w1z2yiym1qyi8p08798g";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          cheapskate clock containers cryptonite data-ordlist deepseq
          directory dlist edit-distance file-embed filepath fsnotify Glob
          haskeline language-javascript lifted-async lifted-base memory
-         microlens microlens-platform monad-control monad-logger mtl
-         parallel parsec pattern-arrows process protolude purescript-cst
-         regex-tdfa safe scientific semialign semigroups serialise sourcemap
-         split stm stringsearch syb text these time transformers
+         microlens microlens-platform monad-control monad-logger
+         monoidal-containers mtl parallel parsec pattern-arrows process
+         protolude regex-tdfa safe scientific semialign semigroups serialise
+         sourcemap split stm stringsearch syb text these time transformers
          transformers-base transformers-compat unordered-containers
          utf8-string vector
        ];
···
          directory dlist edit-distance exceptions file-embed filepath
          fsnotify gitrev Glob haskeline http-types language-javascript
          lifted-async lifted-base memory microlens microlens-platform
-         monad-control monad-logger mtl network optparse-applicative
-         parallel parsec pattern-arrows process protolude purescript-cst
-         regex-tdfa safe scientific semialign semigroups serialise sourcemap
-         split stm stringsearch syb text these time transformers
+         monad-control monad-logger monoidal-containers mtl network
+         optparse-applicative parallel parsec pattern-arrows process
+         protolude regex-tdfa safe scientific semialign semigroups serialise
+         sourcemap split stm stringsearch syb text these time transformers
          transformers-base transformers-compat unordered-containers
-         utf8-string vector wai wai-websockets warp websockets
+         utf8-string vector
        ];
        executableToolDepends = [ happy ];
        testHaskellDepends = [
···
          cheapskate clock containers cryptonite data-ordlist deepseq
          directory dlist edit-distance file-embed filepath fsnotify Glob
          haskeline hspec HUnit language-javascript lifted-async lifted-base
-         memory microlens microlens-platform monad-control monad-logger mtl
-         parallel parsec pattern-arrows process protolude purescript-cst
-         QuickCheck regex-base regex-tdfa safe scientific semialign
-         semigroups serialise sourcemap split stm stringsearch syb text
-         these time transformers transformers-base transformers-compat
+         memory microlens microlens-platform monad-control monad-logger
+         monoidal-containers mtl parallel parsec pattern-arrows process
+         protolude QuickCheck regex-base regex-tdfa safe scientific
+         semialign semigroups serialise sourcemap split stm stringsearch syb
+         text these time transformers transformers-base transformers-compat
          unordered-containers utf8-string vector
        ];
        testToolDepends = [ happy hspec-discover ];
···
        libraryHaskellDepends = [ base primitive transformers util ];
        description = "Class of random value generation";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "random-derive" = callPackage
···
        testHaskellDepends = [ base doctest typecheck-plugin-nat-simple ];
        description = "The list like structure whose length or range of length can be specified";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rangemin" = callPackage
···
        broken = true;
      }) {};
 
+  "refined-with" = callPackage
+    ({ mkDerivation, aeson, base, deepseq, hashable, refined }:
+     mkDerivation {
+       pname = "refined-with";
+       version = "0.3.0";
+       sha256 = "1d74ax7z822xsdnajsja1h49j966s7ym2ah35bpxlikl1l2wsmnh";
+       libraryHaskellDepends = [ aeson base deepseq hashable refined ];
+       description = "Refinement types with an \"refinement applied\" switch";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "refinery" = callPackage
     ({ mkDerivation, base, checkers, exceptions, hspec, mmorph, mtl
      , QuickCheck
···
     ({ mkDerivation, base, containers, mtl, semigroups, text }:
      mkDerivation {
        pname = "reform";
-       version = "0.2.7.4";
-       sha256 = "0dl0jz5ibcj4vafpf0a0v52rac4nmmif69817g7qgxavc093nq82";
-       libraryHaskellDepends = [ base containers mtl semigroups text ];
-       description = "reform is a type-safe HTML form generation and validation library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "reform_0_2_7_5" = callPackage
-    ({ mkDerivation, base, containers, mtl, semigroups, text }:
-     mkDerivation {
-       pname = "reform";
        version = "0.2.7.5";
        sha256 = "14p98i2682dm1n4drdrvilz67wfp2lr7m8f0wlmk40q3qmhc05xb";
        libraryHaskellDepends = [ base containers mtl semigroups text ];
        description = "reform is a type-safe HTML form generation and validation library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "reform-blaze" = callPackage
     ({ mkDerivation, base, blaze-html, blaze-markup, reform, text }:
      mkDerivation {
        pname = "reform-blaze";
-       version = "0.2.4.3";
-       sha256 = "1r5j827diiqybjm75j0gmfb81q7irdc11sj714589xbb6lkz3g0i";
+       version = "0.2.4.4";
+       sha256 = "0cf1nimvkpag4fqs9jk17cl0h9wkpv2lcq5m1l704pznms22s7c7";
        libraryHaskellDepends = [
          base blaze-html blaze-markup reform text
        ];
···
      }:
      mkDerivation {
        pname = "reform-happstack";
-       version = "0.2.5.4";
-       sha256 = "1xknj906vr0q6vrxrvna1777v7hsdg1l3r0wwnga7k1yn5hcfc76";
+       version = "0.2.5.5";
+       sha256 = "0knsx790vf5xvnxhfdz48gz3352z98ghy1ld7yh3rmp1apciqd35";
        libraryHaskellDepends = [
          base bytestring happstack-server mtl random reform text utf8-string
        ];
···
      }:
      mkDerivation {
        pname = "registry-messagepack";
-       version = "0.1.0.2";
-       sha256 = "0pwljb8zdq5m47zjfbmy8827g99y2fai6ib9z2p82kkknag1mg5q";
+       version = "0.1.0.3";
+       sha256 = "0i49cic87jdkfalwbyry7c6f1828vd1n33nkdjmxa73w3vhjklf5";
        libraryHaskellDepends = [
          base containers msgpack protolude registry template-haskell text
          transformers vector
···
      }:
      mkDerivation {
        pname = "restful-snap";
-       version = "0.4.1";
-       sha256 = "1447hbwky8lslblq3vpm7d1zyri4apmf459fbaq3m15kkd1qsyxq";
+       version = "0.4.2";
+       sha256 = "0639j9dv51jra3mx9pqsb9hwrp73cw4xlc27p4hklk3xqr0fvf0p";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers data-default
          digestive-functors errors heist lens map-syntax mtl old-locale
···
        pname = "retrie";
        version = "1.2.0.1";
        sha256 = "1n3g9wr45xz1q2mhlj1r2709rqakczrvd7x6vxh7iapz43f69c6x";
-       revision = "1";
-       editedCabalFile = "0dx1gxf2c88rzd1z83lmvgpbv8xny9yz8px4cjjpnmlrah1fmmqh";
+       revision = "2";
+       editedCabalFile = "0h6r4jg9mnqwvlsl3s6yl2zvhkwr8pdypbzvky4kwz4zvc03j5ql";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "retroclash-lib";
-       version = "0.1.1";
-       sha256 = "1v8xw37cbnz16gqmf65hgk0kvh0vgmq8sj6nh4ngz48l6i5wylv6";
+       version = "0.1.2";
+       sha256 = "11f15nhxp8aaim6yrzlh33dilp2zywdfikgdii44q0mszmm9q0vr";
        libraryHaskellDepends = [
          barbies base clash-ghc clash-lib clash-prelude containers
          ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise
···
        testToolDepends = [ hspec-discover ];
        description = "A standard library for Haskell";
        license = lib.licenses.mit;
+     }) {};
+
+  "rio_0_1_22_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, directory
+     , exceptions, filepath, hashable, hspec, hspec-discover, microlens
+     , microlens-mtl, mtl, primitive, process, QuickCheck, text, time
+     , typed-process, unix, unliftio, unliftio-core
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "rio";
+       version = "0.1.22.0";
+       sha256 = "0rpc4f2yvw0y6mqz9ykm3778j6srya7ssww691kpf9nb8vddgjb6";
+       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
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A standard library for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rio-app" = callPackage
···
        doHaddock = false;
        description = "Row types";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "row-types" = callPackage
···
        license = lib.licenses.mit;
      }) {inherit (pkgs) libsodium;};
 
-  "saltine_0_2_0_0" = callPackage
+  "saltine_0_2_0_1" = callPackage
     ({ mkDerivation, base, bytestring, criterion, deepseq, hashable
      , libsodium, profunctors, QuickCheck, semigroups, test-framework
      , test-framework-quickcheck2, text
      }:
      mkDerivation {
        pname = "saltine";
-       version = "0.2.0.0";
-       sha256 = "1xgrnm6qmm0mymq3dh4mdvzi8sfssnpz06xsrw8zdpa1vl0a0gm6";
+       version = "0.2.0.1";
+       sha256 = "181fxlp8p0zhz58h23fxavhcbxkwhd3a3idlbhawb2rhiah6fs6f";
        libraryHaskellDepends = [
          base bytestring deepseq hashable profunctors text
        ];
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) z3;};
 
+  "sbv_9_0" = callPackage
+    ({ mkDerivation, array, async, base, bytestring, containers
+     , deepseq, directory, filepath, hlint, libBF, mtl, pretty, process
+     , QuickCheck, random, syb, tasty, tasty-bench, tasty-golden
+     , tasty-hunit, tasty-quickcheck, template-haskell, text, time
+     , transformers, uniplate, z3
+     }:
+     mkDerivation {
+       pname = "sbv";
+       version = "9.0";
+       sha256 = "0r84ak8n8vqs1xbvxjzai828yr5msjyf5igf6qmn6f47m0mhf6cz";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         array async base containers deepseq directory filepath libBF mtl
+         pretty process QuickCheck random syb template-haskell text time
+         transformers uniplate
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory filepath hlint mtl process
+         QuickCheck random tasty tasty-golden tasty-hunit tasty-quickcheck
+       ];
+       testSystemDepends = [ z3 ];
+       benchmarkHaskellDepends = [
+         base deepseq filepath process random tasty tasty-bench time
+       ];
+       description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) z3;};
+
   "sbvPlugin" = callPackage
     ({ mkDerivation, base, containers, directory, filepath, ghc
      , ghc-prim, mtl, process, sbv, tasty, tasty-golden
···
      }:
      mkDerivation {
        pname = "sbvPlugin";
-       version = "9.0.1";
-       sha256 = "1hg1sxnspyxjpj98c2h7hzf93m9acw8cjiva4wsnxl1gspln4gwb";
+       version = "9.2.2";
+       sha256 = "0cv2f6n32m8xaii5dpk3kz6wclxgmri1zfh09dq23s91l5asrp1v";
        libraryHaskellDepends = [
          base containers ghc ghc-prim mtl sbv template-haskell
        ];
···
      }:
      mkDerivation {
        pname = "scotty-utils";
-       version = "0.1.0.0";
-       sha256 = "0f77b5xmr5gwswz15i5833karfr1qvyaaiy58khd75n9awfx5jqv";
+       version = "0.2.0.0";
+       sha256 = "0b2r43dcgcq7azcn0l9lxml84h6w5bk09h65y1mlvccwzhwbfini";
        libraryHaskellDepends = [
          aeson aeson-result base http-types scotty text
        ];
···
      }:
      mkDerivation {
        pname = "secp256k1-haskell";
-       version = "0.6.0";
-       sha256 = "0qq37xy61kk5h9h6zaiycjlrr1k9kjddy319qgqi0ja9vkm8msj1";
-       libraryHaskellDepends = [
-         base base16 bytestring cereal deepseq entropy hashable QuickCheck
-         string-conversions unliftio-core
-       ];
-       libraryPkgconfigDepends = [ secp256k1 ];
-       testHaskellDepends = [
-         base base16 bytestring cereal deepseq entropy hashable hspec HUnit
-         monad-par mtl QuickCheck string-conversions unliftio-core
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Bindings for secp256k1";
-       license = lib.licenses.mit;
-     }) {inherit (pkgs) secp256k1;};
-
-  "secp256k1-haskell_0_6_1" = callPackage
-    ({ mkDerivation, base, base16, bytestring, cereal, deepseq, entropy
-     , hashable, hspec, hspec-discover, HUnit, monad-par, mtl
-     , QuickCheck, secp256k1, string-conversions, unliftio-core
-     }:
-     mkDerivation {
-       pname = "secp256k1-haskell";
        version = "0.6.1";
        sha256 = "0abxwmls4rvsnck7p5gpajmha2vc9fbcrr2q1alkpw8acmgfhr76";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Bindings for secp256k1";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) secp256k1;};
 
   "secp256k1-legacy" = callPackage
···
      }:
      mkDerivation {
        pname = "serialise";
-       version = "0.2.4.0";
-       sha256 = "07i50rza58x8j7kw9w2mhbks41gjv6xgnlgfdb0hw2cwdmkrmjqd";
-       revision = "1";
-       editedCabalFile = "0rgc0sr4csmiq38sf6x1xz6cqmp30nn8837xsfwpvcfb7kh4bqy0";
+       version = "0.2.5.0";
+       sha256 = "08ny0bdxd591w4bx6sd16ndik0j8g3578ck6zj667rm1z3ssqqj2";
        libraryHaskellDepends = [
          array base bytestring cborg containers ghc-prim half hashable
          primitive strict text these time unordered-containers vector
···
        ];
        description = "Servant CSV content-type for cassava";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "servant-checked-exceptions" = callPackage
···
      }:
      mkDerivation {
        pname = "servant-errors";
-       version = "0.1.6.0";
-       sha256 = "0qap8wbchpl48aigwqgxrgb6v3d6h80fpxq319c399pwrrkzyh9v";
+       version = "0.1.7.0";
+       sha256 = "0g7mclwxvjw9jwxmd8nkz9a0v4jwm9nxpwlranfdm2f55pa288i1";
        libraryHaskellDepends = [
          aeson base base-compat bytestring http-api-data http-media
          http-types scientific servant string-conversions text
···
     ({ mkDerivation, base, servant-server, text }:
      mkDerivation {
        pname = "servant-htmx";
-       version = "0.1.0.1";
-       sha256 = "1plqqaa3vhmwg37bai6xpi415fd772fx6rf0dr919mc79ms0zcfx";
+       version = "0.1.0.2";
+       sha256 = "06lcs2qv6dxlx6sj16qr426vm7rklv80d720hrw4zfdba5rsl7d9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base servant-server text ];
        executableHaskellDepends = [ base servant-server text ];
        testHaskellDepends = [ base servant-server text ];
-       description = "A library for using htmx with servant";
+       description = "A library for using servant with htmx";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
   "shake-bench" = callPackage
     ({ mkDerivation, aeson, base, Chart, Chart-diagrams
      , diagrams-contrib, diagrams-core, diagrams-lib, diagrams-svg
-     , directory, extra, filepath, lens, lens-aeson, shake, text
+     , directory, extra, filepath, lens, lens-aeson, mtl, shake, text
      }:
      mkDerivation {
        pname = "shake-bench";
-       version = "0.1.0.3";
-       sha256 = "04pngr9a1g7dr7kb0xp9k2yrbg6vqk3lfpksz6bbyydbmypix3ay";
+       version = "0.1.1.0";
+       sha256 = "1p2xa2kxfvzy2c188i9czr5w4jck4sxw2jb7s9dc1b5xf1a4bi01";
        libraryHaskellDepends = [
          aeson base Chart Chart-diagrams diagrams-contrib diagrams-core
          diagrams-lib diagrams-svg directory extra filepath lens lens-aeson
-         shake text
+         mtl shake text
        ];
        description = "Build rules for historical benchmarking";
        license = lib.licenses.asl20;
···
        ];
        description = "A toolkit for making compile-time interpolated templates";
        license = lib.licenses.mit;
+       maintainers = with lib.maintainers; [ psibi ];
+     }) {};
+
+  "shakespeare_2_0_27" = callPackage
+    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
+     , containers, directory, exceptions, file-embed, ghc-prim, hspec
+     , HUnit, parsec, process, scientific, template-haskell, text
+     , th-lift, time, transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "shakespeare";
+       version = "2.0.27";
+       sha256 = "1bnl7m96x8qr2rvkfzjy01d720xb3c55l3vg0zm2lfbz3gpml1jz";
+       libraryHaskellDepends = [
+         aeson base blaze-html blaze-markup bytestring containers directory
+         exceptions file-embed ghc-prim parsec process scientific
+         template-haskell text th-lift time transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base blaze-html blaze-markup bytestring containers directory
+         exceptions ghc-prim hspec HUnit parsec process template-haskell
+         text time transformers
+       ];
+       description = "A toolkit for making compile-time interpolated templates";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ psibi ];
      }) {};
 
···
        pname = "simple-cmd";
        version = "0.2.4";
        sha256 = "19kd863gm33sj01biqz94jk9cy8vb07xlqmw2m9vlh16h3phgqv1";
+       revision = "1";
+       editedCabalFile = "01sqxzvkkj4lvsp3kd8qjb5p2k6ylkiv4a2dc821ihapr0cf2fzj";
        libraryHaskellDepends = [
          base directory extra filepath process unix
        ];
        testHaskellDepends = [ base hspec ];
        description = "Simple String-based process commands";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "simple-cmd_0_2_5" = callPackage
+    ({ mkDerivation, base, directory, extra, filepath, hspec, process
+     , time, unix
+     }:
+     mkDerivation {
+       pname = "simple-cmd";
+       version = "0.2.5";
+       sha256 = "151js143l6b5rg6llvmcy1hcg80cmbp50ydrjhyfjqj32a1ygrsz";
+       libraryHaskellDepends = [
+         base directory extra filepath process time unix
+       ];
+       testHaskellDepends = [ base hspec ];
+       description = "Simple String-based process commands";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "simple-cmd-args" = callPackage
···
      }:
      mkDerivation {
        pname = "simplexmq";
-       version = "1.0.2";
-       sha256 = "142jpsy8myjffx4c1iw21iv210wgnyikmr66bih4gm3xgbqniz9q";
+       version = "1.1.0";
+       sha256 = "1qzrc32bs4s2qn8hz6z0ni5nv89a6vakl5wzk8sa7p2b3fkrc3gw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "smash_0_1_3" = callPackage
+    ({ mkDerivation, base, bifunctors, binary, deepseq, hashable, mtl
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "smash";
+       version = "0.1.3";
+       sha256 = "1i8a8i81xs68zrsv173q0xv0f9cmxmhkgd5k90x60kv7v5pwpqw4";
+       libraryHaskellDepends = [
+         base bifunctors binary deepseq hashable mtl template-haskell
+       ];
+       description = "Combinators for Maybe types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "smash-aeson" = callPackage
     ({ mkDerivation, aeson, base, smash, unordered-containers }:
      mkDerivation {
        pname = "smash-aeson";
-       version = "0.1.0.0";
-       sha256 = "0vmazs3ypqxaw4zdywimxfzrsvidnyk5damx6fpy549ny9319rqs";
-       revision = "1";
-       editedCabalFile = "1y0k6gz9qlr98f543607zkx6a97fnzh3zrbi2b59rlljp0rjvdw8";
+       version = "0.2.0.1";
+       sha256 = "0gbqvm34afkv1v0xajz8cjw0xaih3ls4dh1ygcbybgic08y0xl85";
        libraryHaskellDepends = [ aeson base smash unordered-containers ];
        description = "Aeson support for the smash library";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, lens, smash }:
      mkDerivation {
        pname = "smash-lens";
-       version = "0.1.0.1";
-       sha256 = "1j7v3713aahp3vh7dswrkdfrnksi1zlw9iv9zanhb714s6anyq66";
+       version = "0.1.0.3";
+       sha256 = "0lzvw7349wv1fjsm4q4jwggmjx9cxsrrjydvpq3q12kj6s9p9m5k";
        libraryHaskellDepends = [ base lens smash ];
        testHaskellDepends = [ base ];
        description = "Optics for the `smash` library";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "smash-microlens_0_1_0_2" = callPackage
+    ({ mkDerivation, base, microlens, smash }:
+     mkDerivation {
+       pname = "smash-microlens";
+       version = "0.1.0.2";
+       sha256 = "0rfpdaw1zs8fpw6kp5zkrhj8nmx839fp2ca0cgk14g431yl651ir";
+       libraryHaskellDepends = [ base microlens smash ];
+       testHaskellDepends = [ base ];
+       description = "Optics for the `smash` library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "smash-optics" = callPackage
     ({ mkDerivation, base, optics-core, smash }:
      mkDerivation {
        pname = "smash-optics";
-       version = "0.1.0.1";
-       sha256 = "1jf60vx8hlmyjgap91fvwn0p0hnazpcimshhkz5lsys0ynd4pcwh";
+       version = "0.1.0.2";
+       sha256 = "0acxkswkvbcwd8mawy9w029h01g3l30rkvvy6yzkb693l8xwiiry";
        libraryHaskellDepends = [ base optics-core smash ];
        description = "Optics for the `smash` library using `optics-core`";
        license = lib.licenses.bsd3;
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "Interface to Satisfiability Modulo Theories solvers";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "smt-lib" = callPackage
···
      }:
      mkDerivation {
        pname = "snack";
-       version = "0.1.0.0";
-       sha256 = "01h49r64mg55ii32gnd7bab4rmgp73r3gks9g35z2qgdacwijwac";
+       version = "0.2.0.0";
+       sha256 = "13crnza7fav388s3n8gywbjam97xqhdqh0r10dcgpm5jffi8vns2";
        libraryHaskellDepends = [ base bytestring bytestring-lexing text ];
        benchmarkHaskellDepends = [
          attoparsec base bytestring criterion string-conversions text
        ];
        description = "Strict ByteString Parser Combinator";
-       license = lib.licenses.mit;
+       license = lib.licenses.cc0;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "snap-server";
        version = "1.1.2.0";
        sha256 = "0w4yv9a5ilpma0335ariwap2iscmdbaaif88lq3cm7px910nyc4j";
+       revision = "1";
+       editedCabalFile = "0ijwp0s976cpb4nny8l7vpf5xny6k8dy2xb1rya1l2x5yzj7hlrj";
        configureFlags = [ "-fopenssl" ];
        isLibrary = true;
        isExecutable = true;
···
     ({ mkDerivation, base, blaze-builder, bytestring
      , digestive-functors, digestive-functors-heist
      , digestive-functors-snap, errors, heist, lens, map-syntax
-     , persistent, persistent-postgresql, persistent-template, readable
-     , restful-snap, snap, snap-extras, snaplet-persistent, text, time
-     , transformers, unordered-containers, xmlhtml
+     , persistent, persistent-postgresql, readable, restful-snap, snap
+     , snap-extras, snaplet-persistent, text, time, transformers
+     , unordered-containers, xmlhtml
      }:
      mkDerivation {
        pname = "snaplet-actionlog";
-       version = "0.3.1";
-       sha256 = "1cs1spfy253zf2lxjdx2ki20ikzyj035xcxkzldxkn994amw2p7l";
+       version = "0.4.0";
+       sha256 = "1sg6pni9317v9g0v69b4a8rhnln6bal9iv0znz07ssgj9jg1ppp0";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base blaze-builder bytestring digestive-functors
          digestive-functors-heist digestive-functors-snap errors heist lens
-         map-syntax persistent persistent-postgresql persistent-template
-         readable restful-snap snap snap-extras snaplet-persistent text time
-         transformers unordered-containers xmlhtml
+         map-syntax persistent persistent-postgresql readable restful-snap
+         snap snap-extras snaplet-persistent text time transformers
+         unordered-containers xmlhtml
        ];
        description = "Generic action log snaplet for the Snap Framework";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.mit;
      }) {};
 
+  "store_0_7_15" = callPackage
+    ({ mkDerivation, array, async, base, base-orphans
+     , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector
+     , clock, containers, contravariant, criterion, cryptohash, deepseq
+     , directory, filepath, free, ghc-prim, hashable, hspec
+     , hspec-discover, hspec-smallcheck, integer-gmp, lifted-base
+     , monad-control, mono-traversable, nats, 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.15";
+       sha256 = "0ws8gck230q2wcmgbpynvppd122ag1rksjjg67wcy62dfkzdk264";
+       libraryHaskellDepends = [
+         array async base base-orphans base64-bytestring bifunctors
+         bytestring containers contravariant cryptohash deepseq directory
+         filepath free ghc-prim hashable hspec hspec-smallcheck integer-gmp
+         lifted-base monad-control mono-traversable nats 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 filepath free ghc-prim hashable hspec hspec-smallcheck
+         integer-gmp lifted-base monad-control mono-traversable nats 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
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         array async base base-orphans base64-bytestring bifunctors
+         bytestring cereal cereal-vector containers contravariant criterion
+         cryptohash deepseq directory filepath free ghc-prim hashable hspec
+         hspec-smallcheck integer-gmp lifted-base monad-control
+         mono-traversable nats 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 = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "store-core" = callPackage
     ({ mkDerivation, base, bytestring, ghc-prim, primitive, text
      , transformers
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "string-interpreter";
-       version = "0.5.5.0";
-       sha256 = "094fh3byv0bgcaccq15nqra31cw12csmyqj38hib2a2p6jnc3mq1";
+       version = "0.6.0.0";
+       sha256 = "0a0i95j8y49wijh2c0bpy5fwz72w0p6nh19df56g2yy7xik5h6xq";
        libraryHaskellDepends = [ base ];
        description = "Is used in the phonetic languages approach (e. g. in the recursive mode).";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "stylish-haskell";
-       version = "0.14.1.0";
-       sha256 = "1chgkxqbnrgq7w9zzx118igp08h9vfgp150akazmgimy378cadlk";
+       version = "0.14.2.0";
+       sha256 = "1k2ffsizpy476v3zj6j634ap62qklzv80ryyh7c3j5l2cbzfv0gi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "swish" = callPackage
     ({ mkDerivation, base, containers, directory, filepath, hashable
-     , HUnit, intern, mtl, network-uri, old-locale, polyparse
-     , semigroups, test-framework, test-framework-hunit, text, time
+     , HUnit, intern, mtl, network-uri, polyparse, semigroups
+     , test-framework, test-framework-hunit, text, time
      }:
      mkDerivation {
        pname = "swish";
-       version = "0.10.1.0";
-       sha256 = "0xy12fmmiydaqm0cng24qd7c1py1sbb4ww66w0n5w26kwgh622cc";
+       version = "0.10.2.0";
+       sha256 = "162sq6k9ylzlnqj4l9plykvhhrkc7sc08bza6az5cadfvnqlham8";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base containers directory filepath hashable intern mtl network-uri
-         old-locale polyparse text time
+         polyparse text time
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
-         base containers hashable HUnit network-uri old-locale semigroups
+         base containers hashable HUnit network-uri semigroups
          test-framework test-framework-hunit text time
        ];
        description = "A semantic web toolkit";
···
      , MonadRandom, mtl, optparse-applicative, path, path-io
      , pretty-show, QuickCheck, quickcheck-io, random, random-shuffle
      , safe, safe-coloured-text, safe-coloured-text-terminfo, split, stm
-     , sydtest-discover, text, yaml
+     , sydtest-discover, text
      }:
      mkDerivation {
        pname = "sydtest";
-       version = "0.9.0.0";
-       sha256 = "1gp9kifyh88pjnk7vnb0p09fkcmnhy5akgfdacmrmgwcnyswx6f1";
+       version = "0.10.0.0";
+       sha256 = "009d4ai8dqhxcrgkd0d37l97dkiqh7qmr1wvhwj38mblrhpgpm3z";
        libraryHaskellDepends = [
          async autodocodec autodocodec-yaml base bytestring containers Diff
          dlist envparse filepath MonadRandom mtl optparse-applicative path
          path-io pretty-show QuickCheck quickcheck-io random-shuffle safe
-         safe-coloured-text safe-coloured-text-terminfo split stm text yaml
+         safe-coloured-text safe-coloured-text-terminfo split stm text
        ];
        testHaskellDepends = [
          base bytestring path path-io QuickCheck random safe-coloured-text
···
      }) {};
 
   "sydtest-aeson" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, path
-     , path-io, sydtest, sydtest-discover, text
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, deepseq
+     , directory, path, path-io, sydtest, sydtest-discover, text
      }:
      mkDerivation {
        pname = "sydtest-aeson";
-       version = "0.0.0.0";
-       sha256 = "0x4n27v60m6h44xwpf60j11j1r9r1zzixlszq21skrf2r6lla2gn";
+       version = "0.1.0.0";
+       sha256 = "1kidxlaw8snyzl0nq2vynjz179blh03cvg2qdjr5j521cjxxmwf8";
        libraryHaskellDepends = [
-         aeson aeson-pretty base bytestring path path-io sydtest text
+         aeson aeson-pretty base bytestring deepseq path path-io sydtest
+         text
        ];
-       testHaskellDepends = [ aeson base sydtest text ];
+       testHaskellDepends = [ aeson base directory sydtest text ];
        testToolDepends = [ sydtest-discover ];
        description = "An aeson companion library for sydtest";
        license = "unknown";
···
      }:
      mkDerivation {
        pname = "sydtest-hedgehog";
-       version = "0.1.0.0";
-       sha256 = "0p0aj2jd6cgi3mdzdlwksczikxsx9ajh0lcvd6k4059x1ddjxplb";
+       version = "0.2.0.0";
+       sha256 = "084nqzl1i5phy0hwdgcx0dvlajr8g1iva73f3j9y9rsgl08wh727";
        libraryHaskellDepends = [ base containers hedgehog stm sydtest ];
        testHaskellDepends = [ base hedgehog sydtest ];
        testToolDepends = [ sydtest-discover ];
···
      }:
      mkDerivation {
        pname = "sydtest-hspec";
-       version = "0.1.0.0";
-       sha256 = "17j48cp7n0smci0m42yyvkz0rd5xfrysb2f6hwxaqhl703ifhlyy";
+       version = "0.3.0.0";
+       sha256 = "1vda3jhgnqbs0sw219li3s83vyqr1k1hzvy0prr2c4hv62cr47p3";
        libraryHaskellDepends = [
          base hspec-core mtl QuickCheck stm sydtest
        ];
···
 
   "sydtest-persistent-postgresql" = callPackage
     ({ mkDerivation, base, monad-logger, mtl, persistent
-     , persistent-postgresql, persistent-template, sydtest
-     , sydtest-discover, sydtest-persistent, tmp-postgres
+     , persistent-postgresql, sydtest, sydtest-discover
+     , sydtest-persistent, tmp-postgres
      }:
      mkDerivation {
        pname = "sydtest-persistent-postgresql";
-       version = "0.2.0.0";
-       sha256 = "0c3f9m3d7nryb2xvfp7zrqqi9136mgf89ccwg8vlaapnx1bqap43";
+       version = "0.2.0.1";
+       sha256 = "1j4mb5vxwcdpfnrbk1xk8cg9s93dzndhdg2b4xgb91ix1c2ly5rz";
        libraryHaskellDepends = [
          base monad-logger mtl persistent persistent-postgresql sydtest
          sydtest-persistent tmp-postgres
        ];
        testHaskellDepends = [
-         base persistent persistent-postgresql persistent-template sydtest
+         base persistent persistent-postgresql sydtest
        ];
        testToolDepends = [ sydtest-discover ];
        description = "An persistent-postgresql companion library for sydtest";
···
 
   "sydtest-persistent-sqlite" = callPackage
     ({ mkDerivation, base, monad-logger, mtl, persistent
-     , persistent-sqlite, persistent-template, sydtest, sydtest-discover
-     , sydtest-persistent
+     , persistent-sqlite, sydtest, sydtest-discover, sydtest-persistent
      }:
      mkDerivation {
        pname = "sydtest-persistent-sqlite";
-       version = "0.2.0.0";
-       sha256 = "1l17n6hgc64ngjfdgg6c1zhnlg6ks9bvb7hbv5yf454bhbm6p83s";
+       version = "0.2.0.1";
+       sha256 = "1hy0i03pmdxmrw8nh07m8s7vr9af7m54gw0myn6flw9x57s2zk7v";
        libraryHaskellDepends = [
-         base monad-logger mtl persistent persistent-sqlite
-         persistent-template sydtest sydtest-persistent
+         base monad-logger mtl persistent persistent-sqlite sydtest
+         sydtest-persistent
        ];
-       testHaskellDepends = [
-         base persistent persistent-sqlite persistent-template sydtest
-       ];
+       testHaskellDepends = [ base persistent persistent-sqlite sydtest ];
        testToolDepends = [ sydtest-discover ];
        description = "A persistent-sqlite companion library for sydtest";
        license = "unknown";
···
      }) {};
 
   "sydtest-servant" = callPackage
-    ({ mkDerivation, base, http-client, servant, servant-client
-     , servant-server, stm, sydtest, sydtest-discover, sydtest-wai
+    ({ mkDerivation, base, http-client, servant-client, servant-server
+     , stm, sydtest, sydtest-discover, sydtest-wai
      }:
      mkDerivation {
        pname = "sydtest-servant";
-       version = "0.2.0.1";
-       sha256 = "1yclwmcqp6wkcd980ha7a93dz99zc55mcw2z5fwhk3gfwdpdfyfj";
+       version = "0.2.0.2";
+       sha256 = "0gmaf1p7f588mvcf486wb32qjh74gvqyf965wczh5h0phgyg2f8z";
        libraryHaskellDepends = [
-         base http-client servant servant-client servant-server sydtest
-         sydtest-wai
+         base http-client servant-client servant-server sydtest sydtest-wai
        ];
        testHaskellDepends = [
-         base servant servant-client servant-server stm sydtest sydtest-wai
+         base servant-client servant-server stm sydtest sydtest-wai
        ];
        testToolDepends = [ sydtest-discover ];
        description = "A servant companion library for sydtest";
···
        pname = "telegram-bot-simple";
        version = "0.5";
        sha256 = "0mzzq7lfl56h1i9dr617h5vcv47j2nsf77pkq18s8wk5zrc67r2w";
+       revision = "1";
+       editedCabalFile = "0nz2g3jfb3l66ixrxlz257pmg2qbg7l6wsi0q38iv8fl4483md2s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "text-builder_0_6_7" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, QuickCheck
+     , quickcheck-instances, rerebase, tasty, tasty-hunit
+     , tasty-quickcheck, text, text-builder-dev
+     }:
+     mkDerivation {
+       pname = "text-builder";
+       version = "0.6.7";
+       sha256 = "00pl4jbqpcrfc00m3hf871g9k7s0n6xf2igb7ba1dnqh76w4lw4h";
+       libraryHaskellDepends = [ base bytestring text text-builder-dev ];
+       testHaskellDepends = [
+         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ criterion rerebase ];
+       description = "An efficient strict text builder";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "text-builder-dev" = callPackage
     ({ mkDerivation, base, bytestring, criterion, deferred-folds
      , QuickCheck, quickcheck-instances, rerebase, split, tasty
···
        benchmarkHaskellDepends = [ criterion rerebase ];
        description = "Edge of developments for \"text-builder\"";
        license = lib.licenses.mit;
+     }) {};
+
+  "text-builder-dev_0_3_1" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, deferred-folds
+     , QuickCheck, quickcheck-instances, rerebase, split, tasty
+     , tasty-hunit, tasty-quickcheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "text-builder-dev";
+       version = "0.3.1";
+       sha256 = "18ipiiqrr0hz0yl7lqv2y730vl6mzqp0jg1yir097gp53ky6hzyw";
+       libraryHaskellDepends = [
+         base bytestring deferred-folds split text transformers
+       ];
+       testHaskellDepends = [
+         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ criterion rerebase ];
+       description = "Edge of developments for \"text-builder\"";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "text-containers" = callPackage
···
        benchmarkHaskellDepends = [ base criterion weigh ];
        description = "Pattern language for improvised music";
        license = lib.licenses.gpl3Only;
+     }) {};
+
+  "tidal_1_8_0" = callPackage
+    ({ mkDerivation, async, base, bifunctors, bytestring, clock, colour
+     , containers, criterion, deepseq, exceptions, hint, hosc, microspec
+     , mtl, network, parsec, primitive, random, text, transformers
+     , weigh
+     }:
+     mkDerivation {
+       pname = "tidal";
+       version = "1.8.0";
+       sha256 = "19gh5l8hna9s4k5qw98qcr1s9wpqi6mf2kxd4kz6lzl3yxj56y6z";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bifunctors bytestring clock colour containers deepseq
+         exceptions hosc mtl network parsec primitive random text
+         transformers
+       ];
+       executableHaskellDepends = [ async base exceptions hint ];
+       testHaskellDepends = [
+         base containers deepseq hosc microspec parsec
+       ];
+       benchmarkHaskellDepends = [ base criterion weigh ];
+       description = "Pattern language for improvised music";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tidal-midi" = callPackage
···
 
   "twain" = callPackage
     ({ mkDerivation, aeson, base, bytestring, case-insensitive, cookie
-     , either, exceptions, http-types, http2, text, time, transformers
-     , vault, wai, wai-extra
+     , either, exceptions, hspec, hspec-discover, hspec-wai, http-types
+     , http2, text, time, transformers, vault, wai, wai-extra
      }:
      mkDerivation {
        pname = "twain";
-       version = "2.0.1.0";
-       sha256 = "0wal0qr3bacy7phgbvi2sif5q490jk8mhw675lpl2ch8dmmf769p";
+       version = "2.1.0.0";
+       sha256 = "0ffppxfdrjgqr3csm2cwsc2sgxgrl9dqx60n2zffnh3c7qc7z749";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive cookie either exceptions
          http-types http2 text time transformers vault wai wai-extra
        ];
+       testHaskellDepends = [ base hspec hspec-discover hspec-wai ];
+       testToolDepends = [ hspec-discover ];
        description = "Tiny web application framework for WAI";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ];
        description = "Text";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "txt-sushi" = callPackage
···
      }) {};
 
   "typecheck-plugin-nat-simple" = callPackage
-    ({ mkDerivation, base, containers, ghc }:
+    ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra }:
      mkDerivation {
        pname = "typecheck-plugin-nat-simple";
-       version = "0.1.0.4";
-       sha256 = "0ybkkfk9ha3f1f5cq45r0rmnws0ai6imwic0srf78d6ys3q5n5n5";
+       version = "0.1.0.6";
+       sha256 = "0qhqys9kiisgy8gwfz92ffvmccgan2v95zxyfnbjqj1z9ks26br5";
        enableSeparateDataOutput = true;
-       libraryHaskellDepends = [ base containers ghc ];
-       testHaskellDepends = [ base containers ghc ];
+       libraryHaskellDepends = [
+         base containers ghc ghc-tcplugins-extra
+       ];
+       testHaskellDepends = [ base containers ghc ghc-tcplugins-extra ];
        description = "Simple type check plugin which calculate addition, subtraction and less-or-equal-than";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "typed-admin" = callPackage
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "Universal";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "universal-binary" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "unliftio_0_2_22_0" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, deepseq
+     , directory, filepath, gauge, hspec, process, QuickCheck, stm, time
+     , transformers, unix, unliftio-core
+     }:
+     mkDerivation {
+       pname = "unliftio";
+       version = "0.2.22.0";
+       sha256 = "125vzwkzp53i5n0yxy7bbivpzgf3c7ynsfhn04xk1ymy9fqsvi0z";
+       libraryHaskellDepends = [
+         async base bytestring deepseq directory filepath process stm time
+         transformers unix unliftio-core
+       ];
+       testHaskellDepends = [
+         async base bytestring containers deepseq directory filepath hspec
+         process QuickCheck stm time transformers unix unliftio-core
+       ];
+       benchmarkHaskellDepends = [
+         async base bytestring deepseq directory filepath gauge process stm
+         time transformers unix unliftio-core
+       ];
+       description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unliftio-core" = callPackage
     ({ mkDerivation, base, transformers }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "unordered-containers_0_2_18_0" = callPackage
+  "unordered-containers_0_2_19_1" = callPackage
     ({ mkDerivation, base, bytestring, ChasingBottoms, containers
      , deepseq, hashable, hashmap, HUnit, mtl, nothunks, QuickCheck
      , random, tasty, tasty-bench, tasty-hunit, tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "unordered-containers";
-       version = "0.2.18.0";
-       sha256 = "09cvqdqaqbf0z5i0hbkgn7hkz44plniznj6zimdx0a86i6lhq3b2";
+       version = "0.2.19.1";
+       sha256 = "1li8s6qw8mgv6a7011y7hg0cn2nllv2g9sr9c1xb48nmw32vw9qv";
        libraryHaskellDepends = [ base deepseq hashable template-haskell ];
        testHaskellDepends = [
          base ChasingBottoms containers hashable HUnit nothunks QuickCheck
···
        pname = "util";
        version = "0.1.17.1";
        sha256 = "1qhx4r27sny25sykacf5xi5br4msq4335ghp5zc3fq0lii3866s7";
-       revision = "1";
-       editedCabalFile = "16hbcmcq2674j37gl808n5i02kv0vn3nwq5l2a6v5lj0dn34nicb";
+       revision = "2";
+       editedCabalFile = "0z9bf05jn5y9k5nrjksfpzjml5xchjrj3nk3jh90g8pygs2658rb";
        libraryHaskellDepends = [ base transformers ];
        description = "Utilities";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "util-exception" = callPackage
···
      }:
      mkDerivation {
        pname = "uuid-orphans";
-       version = "1.4.5";
-       sha256 = "14d7gyf3sa2874r0dhj3ydvmb1iz174kp4pxz7aq984zb4m6d87z";
-       revision = "2";
-       editedCabalFile = "1202zn5f70f1yvmaknm8l34igg9ihyqs8lhch4ihvx9vcqxs3c0v";
+       version = "1.4.6";
+       sha256 = "0is5f2fn5ip93wla33dcjpl8hscpcwyv6cpxcmqs25vvbwz27kvz";
        libraryHaskellDepends = [
          base safecopy text th-lift uuid-types web-routes
        ];
···
        libraryHaskellDepends = [ base util ];
        description = "Type isomorphic to `Either` with `Applicative` instance which combines errors";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "valid-names" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "validity_0_12_0_1" = callPackage
+    ({ mkDerivation, base, hspec }:
+     mkDerivation {
+       pname = "validity";
+       version = "0.12.0.1";
+       sha256 = "1j9yswqas9dpb9mv132myfn1rky5vbh5gdvcxbb7p93k5c2y4g0w";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec ];
+       description = "Validity typeclass";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "validity-aeson" = callPackage
     ({ mkDerivation, aeson, base, hspec, validity, validity-scientific
      , validity-text, validity-unordered-containers, validity-vector
      }:
      mkDerivation {
        pname = "validity-aeson";
-       version = "0.2.0.4";
-       sha256 = "1k0x6va9mmz0z9hgd1is71ks4fgbziw53rm7r6jsidp4ksszdzm0";
-       revision = "1";
-       editedCabalFile = "1zhqg6hac0js33yn0xw10pcp11hbygr95vmcmgpp3sdxdhgpbnmy";
+       version = "0.2.0.5";
+       sha256 = "0gk2mqhsailjp3130jgd17j2254kx28fnhhwyi1f66is1axw6cmj";
        libraryHaskellDepends = [
          aeson base validity validity-scientific validity-text
          validity-unordered-containers validity-vector
···
        sha256 = "0ck7pn8c8srwdwpcx6x4ihixff07kigq8q9sjkc3zzyf54n93f3x";
        libraryHaskellDepends = [ base bytestring validity ];
        description = "Validity instances for bytestring";
+       license = lib.licenses.mit;
+     }) {};
+
+  "validity-case-insensitive" = callPackage
+    ({ mkDerivation, base, case-insensitive, genvalidity-hspec, hspec
+     , validity
+     }:
+     mkDerivation {
+       pname = "validity-case-insensitive";
+       version = "0.0.0.0";
+       sha256 = "075pxgviqmf5xi4if15mbabn32xw11nss19a4il9z9ng1fsrcn1d";
+       libraryHaskellDepends = [ base case-insensitive validity ];
+       testHaskellDepends = [
+         base case-insensitive genvalidity-hspec hspec validity
+       ];
+       description = "Validity instances for case-insensitive";
        license = lib.licenses.mit;
      }) {};
 
···
        libraryHaskellDepends = [ base bytestring text validity ];
        description = "Validity instances for text";
        license = lib.licenses.mit;
+     }) {};
+
+  "validity-text_0_3_1_3" = callPackage
+    ({ mkDerivation, base, bytestring, text, validity }:
+     mkDerivation {
+       pname = "validity-text";
+       version = "0.3.1.3";
+       sha256 = "0igxjd53aqlhhnjilbyjsxs4hjc8b21mpi504kc8c60q0ysq7vks";
+       libraryHaskellDepends = [ base bytestring text validity ];
+       description = "Validity instances for text";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "validity-time" = callPackage
···
      }:
      mkDerivation {
        pname = "wai-extra";
-       version = "3.1.8";
-       sha256 = "0ddgdr0304b3kg50vfjsg3bxlhfp3vmsb4c8i80k8adqzh54hz5l";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson ansi-terminal base base64-bytestring bytestring call-stack
-         case-insensitive containers cookie data-default-class directory
-         fast-logger http-types http2 HUnit iproute network resourcet
-         streaming-commons text time transformers unix vault wai wai-logger
-         word8
-       ];
-       testHaskellDepends = [
-         aeson base bytestring case-insensitive cookie fast-logger hspec
-         http-types http2 HUnit iproute resourcet text time transformers wai
-         zlib
-       ];
-       description = "Provides some basic WAI handlers and middleware";
-       license = lib.licenses.mit;
-     }) {};
-
-  "wai-extra_3_1_10" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, base, base64-bytestring
-     , bytestring, call-stack, case-insensitive, containers, cookie
-     , data-default-class, directory, fast-logger, hspec, http-types
-     , http2, HUnit, iproute, network, resourcet, streaming-commons
-     , text, time, transformers, unix, vault, wai, wai-logger, word8
-     , zlib
-     }:
-     mkDerivation {
-       pname = "wai-extra";
        version = "3.1.10";
        sha256 = "0ldzwcjgj0k3ma25y4jaywv4g4bjjnn75ixlk1h4r4f3iapxm6kr";
        isLibrary = true;
···
        ];
        description = "Provides some basic WAI handlers and middleware";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "wai-feature-flags" = callPackage
···
      }:
      mkDerivation {
        pname = "web-routes";
-       version = "0.27.14.3";
-       sha256 = "1a66m261ilqafbwwgjvalh3rz38qxcwxw9a99wr18lm0ah27lvx4";
-       libraryHaskellDepends = [
-         base blaze-builder bytestring exceptions ghc-prim http-types mtl
-         parsec split text utf8-string
-       ];
-       testHaskellDepends = [ base hspec HUnit QuickCheck text ];
-       description = "portable, type-safe URL routing";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "web-routes_0_27_14_4" = callPackage
-    ({ mkDerivation, base, blaze-builder, bytestring, exceptions
-     , ghc-prim, hspec, http-types, HUnit, mtl, parsec, QuickCheck
-     , split, text, utf8-string
-     }:
-     mkDerivation {
-       pname = "web-routes";
        version = "0.27.14.4";
        sha256 = "10zpyxigrmp97x7xd9aw8kn925ygjf0jv8hppxmksjf9a6pvyfn1";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base hspec HUnit QuickCheck text ];
        description = "portable, type-safe URL routing";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "web-routes-boomerang" = callPackage
-    ({ mkDerivation, base, boomerang, mtl, parsec, text, web-routes }:
-     mkDerivation {
-       pname = "web-routes-boomerang";
-       version = "0.28.4.2";
-       sha256 = "09vq5gfxibrbh65a4y94crcb99s848rx56grmfny89ccdv6r5a3y";
-       libraryHaskellDepends = [
-         base boomerang mtl parsec text web-routes
-       ];
-       description = "Use boomerang for type-safe URL parsers/printers";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "web-routes-boomerang_0_28_4_3" = callPackage
     ({ mkDerivation, base, boomerang, mtl, parsec, text, web-routes }:
      mkDerivation {
        pname = "web-routes-boomerang";
···
        ];
        description = "Use boomerang for type-safe URL parsers/printers";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "web-routes-generics" = callPackage
···
      }:
      mkDerivation {
        pname = "web-routes-happstack";
-       version = "0.23.12.1";
-       sha256 = "06gifknfv6g9rd9f83r75hc3sld4xb4f1czxs9k5ca7n1l1vlccy";
-       libraryHaskellDepends = [
-         base bytestring happstack-server text web-routes
-       ];
-       description = "Adds support for using web-routes with Happstack";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "web-routes-happstack_0_23_12_2" = callPackage
-    ({ mkDerivation, base, bytestring, happstack-server, text
-     , web-routes
-     }:
-     mkDerivation {
-       pname = "web-routes-happstack";
        version = "0.23.12.2";
        sha256 = "01ks9c8bln8yiff7dqfm3ai7scci304q94w1zaqvzph57m1whrd6";
        libraryHaskellDepends = [
···
        ];
        description = "Adds support for using web-routes with Happstack";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "web-routes-hsp" = callPackage
-    ({ mkDerivation, base, hsp, text, web-routes }:
-     mkDerivation {
-       pname = "web-routes-hsp";
-       version = "0.24.6.1";
-       sha256 = "1arc22l7xk49fp80i1fkvj8xj71lqxrs2g5gnvjzwlkc0azzaz6a";
-       libraryHaskellDepends = [ base hsp text web-routes ];
-       description = "Adds XMLGenerator instance for RouteT monad";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "web-routes-hsp_0_24_6_2" = callPackage
     ({ mkDerivation, base, hsp, text, web-routes }:
      mkDerivation {
        pname = "web-routes-hsp";
···
        libraryHaskellDepends = [ base hsp text web-routes ];
        description = "Adds XMLGenerator instance for RouteT monad";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "web-routes-mtl" = callPackage
···
      }:
      mkDerivation {
        pname = "web-routes-wai";
-       version = "0.24.3.1";
-       sha256 = "0j9h22nsj7zf5qpf4i07jdcih00r2fivdilvj8wsylk4d23x27wf";
-       libraryHaskellDepends = [
-         base bytestring http-types text wai web-routes
-       ];
-       description = "Library for maintaining correctness of URLs within an application";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "web-routes-wai_0_24_3_2" = callPackage
-    ({ mkDerivation, base, bytestring, http-types, text, wai
-     , web-routes
-     }:
-     mkDerivation {
-       pname = "web-routes-wai";
        version = "0.24.3.2";
        sha256 = "1cdahkpw0194gdx11g4h4313ni0b6sdj9j5r666rgwwzr22wgql7";
        libraryHaskellDepends = [
···
        ];
        description = "Library for maintaining correctness of URLs within an application";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "web-routing" = callPackage
···
        pname = "xmlhtml";
        version = "0.2.5.2";
        sha256 = "1p2v1cj9jjwbqyb0fyv2201zd7ljz5d46qg5kwy7rz2bchbqd0b4";
-       revision = "3";
-       editedCabalFile = "00a7ymnzf87p6dv6mphziycyx6p97xbbbvg8fzbqa6am4pvr029z";
+       revision = "4";
+       editedCabalFile = "1q4f9pvyrkrw793kvd1lxzpzf49h2rs8zdmmhsli487sllflghnq";
        libraryHaskellDepends = [
          base blaze-builder blaze-html blaze-markup bytestring
          bytestring-builder containers parsec text unordered-containers
···
        license = lib.licenses.mit;
      }) {};
 
+  "yaml-unscrambler_0_1_0_10" = callPackage
+    ({ mkDerivation, acc, attoparsec, attoparsec-data, attoparsec-time
+     , base, base64-bytestring, bytestring, conduit, containers, foldl
+     , hashable, libyaml, mtl, neat-interpolation, QuickCheck
+     , quickcheck-instances, rerebase, scientific, selective, tasty
+     , tasty-hunit, tasty-quickcheck, text, text-builder-dev, time
+     , transformers, unordered-containers, uuid, vector, yaml
+     }:
+     mkDerivation {
+       pname = "yaml-unscrambler";
+       version = "0.1.0.10";
+       sha256 = "07pwdd6w6gh0x05925hfk5mhzmig6rh9yb87rkyx15197r9hj7xw";
+       libraryHaskellDepends = [
+         acc attoparsec attoparsec-data attoparsec-time base
+         base64-bytestring bytestring conduit containers foldl hashable
+         libyaml mtl scientific selective text text-builder-dev time
+         transformers unordered-containers uuid vector yaml
+       ];
+       testHaskellDepends = [
+         foldl neat-interpolation QuickCheck quickcheck-instances rerebase
+         tasty tasty-hunit tasty-quickcheck
+       ];
+       description = "Flexible declarative YAML parsing toolkit";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "yaml2owl" = callPackage
     ({ mkDerivation, base, containers, directory, filepath, network
      , network-uri, swish, text, xml, yaml
···
      }:
      mkDerivation {
        pname = "yesod-core";
-       version = "1.6.22.0";
-       sha256 = "0vc60va1lj7a409ljpipk90k89pycsf7zfpvdn0bvsqgsy75qgq6";
+       version = "1.6.23";
+       sha256 = "06v475xa2qbgsqx2gk1lz4y8xwb4d1ak06cw75ig3ji7d1knq4w2";
        libraryHaskellDepends = [
          aeson auto-update base blaze-html blaze-markup bytestring
          case-insensitive cereal clientsession conduit conduit-extra
···
        ];
        description = "Creation of type-safe, RESTful web applications";
        license = lib.licenses.mit;
+     }) {};
+
+  "yesod-core_1_6_23_1" = callPackage
+    ({ mkDerivation, aeson, async, auto-update, base, blaze-html
+     , blaze-markup, bytestring, case-insensitive, cereal, clientsession
+     , conduit, conduit-extra, containers, cookie, deepseq, entropy
+     , fast-logger, gauge, hspec, hspec-expectations, http-types, HUnit
+     , memory, monad-logger, mtl, network, parsec, path-pieces
+     , primitive, random, resourcet, shakespeare, streaming-commons
+     , template-haskell, text, time, transformers, unix-compat, unliftio
+     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
+     , word8
+     }:
+     mkDerivation {
+       pname = "yesod-core";
+       version = "1.6.23.1";
+       sha256 = "1s9wa9xw9ximivwv9bk7lf4w20yhlcy8vyp2i3j6w4fig918qxg9";
+       libraryHaskellDepends = [
+         aeson auto-update base blaze-html blaze-markup bytestring
+         case-insensitive cereal clientsession conduit conduit-extra
+         containers cookie deepseq entropy fast-logger http-types memory
+         monad-logger mtl parsec path-pieces primitive random resourcet
+         shakespeare template-haskell text time transformers unix-compat
+         unliftio unordered-containers vector wai wai-extra wai-logger warp
+         word8
+       ];
+       testHaskellDepends = [
+         async base bytestring clientsession conduit conduit-extra
+         containers cookie hspec hspec-expectations http-types HUnit network
+         path-pieces random resourcet shakespeare streaming-commons
+         template-haskell text transformers unliftio wai wai-extra warp
+       ];
+       benchmarkHaskellDepends = [
+         base blaze-html bytestring gauge shakespeare text
+       ];
+       description = "Creation of type-safe, RESTful web applications";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-crud" = callPackage
···
      }:
      mkDerivation {
        pname = "yesod-test";
-       version = "1.6.12";
-       sha256 = "1xgy7dzhqjgllqcpyyxs0spdg6vlz2c1sjvni7w7qnsf0ckyw2l8";
-       libraryHaskellDepends = [
-         aeson attoparsec base blaze-builder blaze-html bytestring
-         case-insensitive conduit containers cookie hspec-core html-conduit
-         http-types HUnit memory mtl network pretty-show text time
-         transformers wai wai-extra xml-conduit xml-types yesod-core
-       ];
-       testHaskellDepends = [
-         base bytestring containers cookie hspec html-conduit http-types
-         HUnit text unliftio unliftio-core wai wai-extra xml-conduit
-         yesod-core yesod-form
-       ];
-       description = "integration testing for WAI/Yesod Applications";
-       license = lib.licenses.mit;
-     }) {};
-
-  "yesod-test_1_6_13" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
-     , bytestring, case-insensitive, conduit, containers, cookie, hspec
-     , hspec-core, html-conduit, http-types, HUnit, memory, mtl, network
-     , pretty-show, text, time, transformers, unliftio, unliftio-core
-     , wai, wai-extra, xml-conduit, xml-types, yesod-core, yesod-form
-     }:
-     mkDerivation {
-       pname = "yesod-test";
        version = "1.6.13";
        sha256 = "1r5ip85x0shv00dvznd201fbl9gi90nkk33szmh0cz77x8960v19";
        libraryHaskellDepends = [
···
        ];
        description = "integration testing for WAI/Yesod Applications";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-test-json" = callPackage
···
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
+
+  "zyre2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, czmq, inline-c, text
+     , zyre
+     }:
+     mkDerivation {
+       pname = "zyre2";
+       version = "0.1.1.0";
+       sha256 = "0dqlp60mamqmga6g87qawxg1646czgzhqm441cxpw1dkrshv08jk";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers inline-c text
+       ];
+       librarySystemDepends = [ czmq zyre ];
+       executableHaskellDepends = [
+         base bytestring containers inline-c text
+       ];
+       testHaskellDepends = [ base bytestring containers inline-c text ];
+       description = "Haskell zyre bindings for reliable group messaging over local area networks";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {inherit (pkgs) czmq; zyre = null;};
 
 }

pkgs/development/tools/purescript/spago/spago.nix

···
 }:
 mkDerivation {
   pname = "spago";
-  version = "0.20.8";
+  version = "0.20.9";
   src = fetchgit {
     url = "https://github.com/purescript/spago.git";
-    sha256 = "0lakss2pg5kwbxqsmvzgkcc70l6j40cj9rarhkpcf0kxw98bb5x0";
-    rev = "744bdbbefc538750d4c36888ee53dc5d336314c4";
+    sha256 = "00vdqg7vaw3d9zwh47886lw9fhhlwjagzhaj3aqz4xm92pjavhih";
+    rev = "d16d4914200783fbd820ba89dbdf67270454faf5";
     fetchSubmodules = true;
   };
   isLibrary = true;

pkgs/development/tools/purescript/spago/update.sh

···
 # TODO: This should ideally also automatically update the docsSearchVersion
 # from pkgs/development/haskell/configuration-nix.nix.
 
-echo "Finished."
+echo
+echo "Finished.  Make sure you run the following commands to confirm Spago builds correctly:"
+echo ' - `nix build -L -f ./. spago`'
+echo ' - `sudo nix build -L -f ./. spago.passthru.tests --option sandbox relaxed`'

pkgs/top-level/release-haskell.nix

···
                 random
                 QuickCheck
                 cabal2nix
+                xhtml # isn't bundled for cross
               ;
             };
 
···
                 random
                 QuickCheck
                 cabal2nix
+                xhtml # isn't bundled for cross
               ;
             };
           };