Merge pull request #82849 from NixOS/haskell-updates

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

maintainers/maintainer-list.nix

···
     githubId = 2507744;
     name = "Roland Koebler";
   };
+  rkrzr = {
+    email = "[e-mail]";
+    github = "rkrzr";
+    githubId = 82817;
+    name = "Robert Kreuzer";
+  };
   rlupton20 = {
     email = "[e-mail]";
     github = "rlupton20";

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

···
     '';
   });
 
-  # Version bounds for http-client are too strict:
-  # https://github.com/bitnomial/prometheus/issues/34
-  prometheus = doJailbreak super.prometheus;
-
-  # Tasty-tap tests are out-of-date with TAP format
-  # https://github.com/MichaelXavier/tasty-tap/issues/2
-  tasty-tap = appendPatch super.tasty-tap (pkgs.fetchpatch {
-    url = https://patch-diff.githubusercontent.com/raw/MichaelXavier/tasty-tap/pull/3.diff;
-    sha256 = "0l8zbc56dy8ilxl3k49aiknmfhgpcg3jhs72lh3dk51d0a09d9sv";
-  });
-
   # The doctests in universum-1.5.0 are broken.  The doctests in versions of universum after
   # 1.5.0 should be fixed, so this should be able to be removed.
   universum = dontCheck super.universum;
···
     '';
     sha256 = "097wqn8hxsr50b9mhndg5pjim5jma2ym4ylpibakmmb5m98n17zp";
   });
+
+  # Needs a version that's newer than LTS-15.x provides.
+  weeder = super.weeder.override { generic-lens = self.generic-lens_2_0_0_0;  };
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   # Newer versions don't compile.
   resolv = self.resolv_0_1_1_2;
 
+  # The old Haddock cannot process the newer documentation syntax.
+  fast-logger = dontHaddock super.fast-logger;
+
 }

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

···
   # gi-gdkx11-4.x requires gtk-4.x, which is still under development and
   # not yet available in Nixpkgs
   - gi-gdkx11 < 4
-  # LTS Haskell 15.3
+  # LTS Haskell 15.4
   - abstract-deque ==0.3
   - abstract-par ==0.3.3
   - AC-Angle ==1.0
···
   - function-builder ==0.3.0.1
   - functor-classes-compat ==1
   - fused-effects ==1.0.2.0
-  - fusion-plugin ==0.1.1
   - fusion-plugin-types ==0.1.0
   - fuzzcheck ==0.1.1
   - fuzzy ==0.1.0.0
···
   - ghc-compact ==0.1.0.0
   - ghc-core ==0.5.6
   - ghc-exactprint ==0.6.2
-  - ghcid ==0.8.1
+  - ghcid ==0.8.3
   - ghci-hexcalc ==0.1.1.0
   - ghcjs-codemirror ==0.0.0.2
   - ghc-lib ==8.8.3.20200224
   - ghc-lib-parser ==8.8.3.20200224
-  - ghc-lib-parser-ex ==8.8.5.3
+  - ghc-lib-parser-ex ==8.8.5.6
   - ghc-paths ==0.1.0.12
   - ghc-prof ==1.4.1.6
   - ghc-source-gen ==0.3.0.0
···
   - ghc-tcplugins-extra ==0.4
   - ghc-typelits-extra ==0.3.3
   - ghc-typelits-knownnat ==0.7.2
-  - ghc-typelits-natnormalise ==0.7.1
+  - ghc-typelits-natnormalise ==0.7.2
   - ghc-typelits-presburger ==0.3.0.0
   - ghost-buster ==0.1.1.0
   - gi-atk ==2.0.21
···
   - HaXml ==1.25.5
   - haxr ==3000.11.4
   - hdaemonize ==0.5.6
+  - headroom ==0.1.2.0
   - heap ==1.0.4
   - heaps ==0.3.6.1
   - heart-core ==0.1.1
···
   - http2 ==2.0.3
   - HTTP ==4000.3.14
   - http-api-data ==0.4.1.1
-  - http-client ==0.6.4
+  - http-client ==0.6.4.1
   - http-client-openssl ==0.3.0.0
   - http-client-overrides ==0.1.1.0
   - http-client-tls ==0.3.5.3
   - http-common ==0.8.2.0
   - http-conduit ==2.3.7.3
   - http-date ==0.0.8
-  - http-directory ==0.1.7
+  - http-directory ==0.1.8
   - http-download ==0.1.0.1
   - httpd-shed ==0.4.1.1
   - http-link-header ==1.0.3.1
···
   - hvect ==0.4.0.0
   - hvega ==0.5.0.0
   - hw-balancedparens ==0.3.0.5
-  - hw-bits ==0.7.1.2
+  - hw-bits ==0.7.1.5
   - hw-conduit ==0.2.0.6
   - hw-conduit-merges ==0.2.0.0
   - hw-diagnostics ==0.0.0.7
···
   - hybrid-vectors ==0.2.2
   - hyperloglog ==0.4.3
   - hyphenation ==0.8
-  - hyraxAbif ==0.2.3.21
   - iconv ==0.4.1.3
   - identicon ==0.2.2
   - ieee754 ==0.8.0
···
   - Imlib ==0.1.2
   - immortal ==0.3
   - include-file ==0.1.0.4
-  - incremental-parser ==0.4
+  - incremental-parser ==0.4.0.1
   - indents ==0.5.0.1
   - indexed ==0.1.3
   - indexed-list-literals ==0.2.1.2
···
   - mysql-simple ==0.4.5
   - n2o ==0.11.1
   - nagios-check ==0.3.2
-  - names-th ==0.3.0.0
+  - names-th ==0.3.0.1
   - nano-erl ==0.1.0.1
   - nanospec ==0.2.2
   - nats ==1.1.2
···
   - nettle ==0.3.0
   - netwire ==5.0.3
   - netwire-input ==0.0.7
-  - netwire-input-glfw ==0.0.10
+  - netwire-input-glfw ==0.0.11
   - network ==3.1.1.1
   - network-bsd ==2.8.1.0
   - network-byte-order ==0.1.4.0
···
   - servant-swagger-ui-redoc ==0.3.3.1.22.3
   - servant-websockets ==2.0.0
   - servant-yaml ==0.1.0.1
-  - serverless-haskell ==0.10.1
+  - serverless-haskell ==0.10.2
   - serversession ==1.0.1
   - serversession-frontend-wai ==1.0
   - ses-html ==0.4.0.0
···
   - special-values ==0.1.0.0
   - speculate ==0.4.1
   - speedy-slice ==0.3.0
-  - Spintax ==0.3.3
+  - Spintax ==0.3.4
   - splice ==0.6.1.1
   - split ==0.2.3.4
   - splitmix ==0.0.4
   - spoon ==0.3.1
   - spreadsheet ==0.1.3.8
-  - sql-words ==0.1.6.3
+  - sql-words ==0.1.6.4
   - srcloc ==0.5.1.2
-  - stache ==2.1.0
+  - stache ==2.1.1
   - stack-templatizer ==0.1.0.2
   - starter ==0.3.0
   - stateref ==0.3
···
   - thyme ==0.3.5.5
   - tidal ==1.4.8
   - tile ==0.3.0.0
-  - time-compat ==1.9.2.2
+  - time-compat ==1.9.3
   - timeit ==2.0
   - timelens ==0.2.0.2
   - time-lens ==0.4.0.2
···
   - tuples-homogenous-h98 ==0.1.1.0
   - tuple-sop ==0.3.1.0
   - tuple-th ==0.2.5
-  - turtle ==1.5.16
+  - turtle ==1.5.17
   - TypeCompose ==0.9.14
   - typed-process ==0.2.6.0
   - typed-uuid ==0.0.0.2
···
   - wai-app-static ==3.1.7.1
   - wai-conduit ==3.0.0.4
   - wai-cors ==0.2.7
-  - wai-enforce-https ==0.0.2
+  - wai-enforce-https ==0.0.2.1
   - wai-eventsource ==3.0.0
   - wai-extra ==3.0.29.1
   - wai-handler-launch ==3.0.3.1
···
   - xss-sanitize ==0.3.6
   - xturtle ==0.2.0.0
   - xxhash-ffi ==0.2.0.0
-  - yaml ==0.11.2.0
+  - yaml ==0.11.3.0
   - yesod ==1.6.0.1
   - yesod-auth ==1.6.9
   - yesod-auth-hashdb ==1.7.1.2
···
     - streaming-wai
   kiwi:
     # - glirc
-    - matterhorn
     - Unique
   psibi:
     - path-pieces
     - persistent
-    - persistent-postgresql
     - persistent-sqlite
     - persistent-template
     - shakespeare
   abbradar:
     - Agda
-  roberth:
-    - arion-compose
   cdepillabout:
     - pretty-simple
-    - purescript
     - spago
     - termonad
+  rkrzr:
+    - icepeak
 
 unsupported-platforms:
   alsa-mixer:                                   [ x86_64-darwin ]
···
   - alex-prelude
   - alfred
   - alga
+  - algebra-checkers
   - algebra-dag
   - algebra-sql
   - algebraic
···
   - arbor-monad-metric
   - arbor-monad-metric-datadog
   - arbtt
+  - archive-libarchive
   - archive-tar-bytestring
   - archiver
   - archlinux
···
   - arguedit
   - ariadne
   - arion
+  - arion-compose
   - armada
   - armor
   - arpa
···
   - atomic-primops-vector
   - atomo
   - atp-haskell
+  - ats-pkg
   - ats-setup
   - ats-storable
   - attempt
···
   - awesomium-raw
   - aws-configuration-tools
   - aws-dynamodb-conduit
+  - aws-dynamodb-streams
+  - aws-easy
+  - aws-ec2
   - aws-ec2-knownhosts
   - aws-elastic-transcoder
+  - aws-general
+  - aws-kinesis
   - aws-kinesis-client
   - aws-kinesis-reshard
+  - aws-lambda
+  - aws-lambda-haskell-runtime
   - aws-mfa-credentials
   - aws-performance-tests
+  - aws-route53
   - aws-sdk
+  - aws-sdk-text-converter
+  - aws-sdk-xml-unordered
   - aws-sign4
   - aws-simple
+  - aws-sns
   - axel
   - axiom
   - azubi
···
   - binary-tagged
   - binary-typed
   - bind-marshal
+  - BinderAnn
   - binding-core
   - binding-gtk
   - binding-wx
···
   - cgrep
   - chalkboard
   - chalkboard-viewer
+  - character-cases
   - charade
   - chart-cli
   - Chart-fltkhs
···
   - concurrent-buffer
   - Concurrent-Cache
   - concurrent-machines
+  - concurrent-resource-map
   - concurrent-state
   - concurrent-utilities
   - Concurrential
···
   - conduit-vfs-zip
   - conf
   - confcrypt
+  - conferer-hedis
+  - conferer-provider-dhall
+  - conferer-provider-yaml
+  - conferer-snap
   - confetti
   - conffmt
   - confide
···
   - cparsing
   - CPBrainfuck
   - cpio-conduit
+  - cpkg
   - CPL
   - cplusplus-th
   - cprng-aes-effect
···
   - dhall-nix
   - dhall-text
   - dhall-to-cabal
+  - dhall-yaml
   - dhcp-lease-parser
   - dhrun
   - dia-base
···
   - doublify-toolkit
   - dow
   - download-media-content
+  - downloader
   - dozenal
   - dozens
   - DP
···
   - ekg-bosun
   - ekg-carbon
   - ekg-cloudwatch
-  - ekg-core
   - ekg-elastic
   - ekg-elasticsearch
   - ekg-influxdb
   - ekg-json
   - ekg-log
-  - ekg-prometheus-adapter
   - ekg-push
   - ekg-rrd
   - ekg-statsd
···
   - funspection
   - fused-effects-squeal
   - fusion
+  - fusion-plugin
   - futun
   - future
   - fuzzy-time-gen
···
   - ghc-srcspan-plugin
   - ghc-syb
   - ghc-syb-utils
+  - ghc-tags-plugin
   - ghc-time-alloc-prof
   - ghc-usage
   - ghc-vis
···
   - haskmon
   - haskoin
   - haskoin-bitcoind
-  - haskoin-core
   - haskoin-crypto
   - haskoin-node
   - haskoin-protocol
···
   - hasql-generic
   - hasql-implicits
   - hasql-migration
+  - hasql-notifications
   - hasql-optparse-applicative
   - hasql-pool
   - hasql-postgres
   - hasql-postgres-options
   - hasql-simple
+  - hasql-th
   - hastache
   - hastache-aeson
   - haste
···
   - hdph-closure
   - hdr-histogram
   - HDRUtils
+  - headed-megaparsec
   - headergen
   - headroom
   - heapsort
···
   - HLearn-datastructures
   - HLearn-distributions
   - hledger-api
+  - hledger-chart
+  - hledger-irr
+  - hledger-vty
   - hlibBladeRF
   - hlibev
   - hlibfam
···
   - iban
   - ical
   - iCalendar
-  - icepeak
   - IcoGrid
   - iconv-typed
   - ide-backend
···
   - lhe
   - lhs2TeX-hl
   - lhslatex
+  - libarchive
   - LibClang
   - libconfig
   - libcspm
···
   - lzma-streams
   - maam
   - mac
+  - macaroon-shop
   - macbeth-lib
   - machinecell
   - machines-amazonka
···
   - matrix-as-xyz
   - matrix-market
   - matsuri
+  - matterhorn
+  - mattermost-api
+  - mattermost-api-qc
   - maude
   - maxent
   - maxent-learner-hw
···
   - oidc-client
   - ois-input-manager
   - olwrapper
+  - om-actor
   - om-elm
+  - om-fail
   - omaketex
   - ombra
   - Omega
···
   - opensoundcontrol-ht
   - openssh-github-keys
   - openssh-protocol
+  - opentelemetry-http-client
   - opentelemetry-lightstep
+  - opentelemetry-wai
   - opentheory-char
   - opentok
   - opentype
···
   - persistent-migration
   - persistent-mongoDB
   - persistent-mysql-haskell
+  - persistent-postgresql
   - persistent-protobuf
   - persistent-ratelimit
   - persistent-redis
···
   - pure-priority-queue
   - pure-priority-queue-tests
   - purebred-email
+  - purescript
   - purescript-iso
   - purescript-tsd-gen
   - push-notifications
···
   - rethinkdb-client-driver
   - rethinkdb-model
   - rethinkdb-wereHamster
+  - retrie
   - retryer
   - reverse-geocoding
   - reversi
···
   - ring-buffer
   - ring-buffers
   - riot
+  - risc-v
   - risc386
   - riscv-isa
   - Ritt-Wu
···
   - rpc-framework
   - rpf
   - rpm
+  - rrule
   - rsagl
   - rsagl-frp
   - rsagl-math
···
   - safe-failure-cme
   - safe-freeze
   - safe-globals
+  - safe-json
   - safe-lazy-io
   - safe-length
   - safe-money-xmlbf
···
   - seclib
   - second-transfer
   - secp256k1
-  - secp256k1-haskell
   - secp256k1-legacy
   - secret-santa
   - secret-sharing
···
   - sendgrid-v3
   - sensei
   - sensenet
+  - sensu-run
   - sentence-jp
   - sentry
   - seonbi
···
   - sha-streams
   - shade
   - shadower
+  - shake-bindist
   - shake-cabal-build
   - shake-extras
   - shake-minify
···
   - skews
   - skulk
   - skylark-client
+  - skylighting-lucid
   - skype4hs
   - slack
   - slack-notify-haskell
···
   - sql-simple-sqlite
   - sqlcipher
   - sqlite
-  - sqlite-simple
   - sqlite-simple-errors
   - sqlite-simple-typed
   - sqlvalue-list
···
   - tasty-laws
   - tasty-lens
   - tasty-stats
-  - tasty-tap
   - tateti-tateti
   - Taxonomy
   - TaxonomyTools
···
   - traced
   - tracetree
   - tracing
+  - tracked-files
   - tracker
   - trackit
   - traction
···
   - validate-input
   - validated-types
   - Validation
+  - validation-selective
   - validations
   - validationt
   - value-supply

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

···
   # requires autotools to build
   secp256k1 = addBuildTools super.secp256k1 [ pkgs.buildPackages.autoconf pkgs.buildPackages.automake pkgs.buildPackages.libtool ];
 
+  # requires libsecp256k1 in pkgconfig-depends
+  secp256k1-haskell = addPkgconfigDepend super.secp256k1-haskell pkgs.secp256k1;
+
   # tests require git and zsh
   hapistrano = addBuildTools super.hapistrano [ pkgs.buildPackages.git pkgs.buildPackages.zsh ];
 

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

···
   "Agda" = callPackage
     ({ mkDerivation, aeson, alex, array, async, base, binary
      , blaze-html, boxes, bytestring, Cabal, containers, data-hash
-     , deepseq, directory, EdisonCore, edit-distance, emacs, equivalence
-     , exceptions, filepath, geniplate-mirror, gitrev, happy, hashable
+     , deepseq, directory, edit-distance, emacs, equivalence, exceptions
+     , filepath, geniplate-mirror, ghc-compact, gitrev, happy, hashable
      , hashtables, haskeline, ieee754, mtl, murmur-hash, pretty, process
      , regex-tdfa, split, stm, strict, template-haskell, text, time
-     , unordered-containers, uri-encode, zlib
+     , transformers, unordered-containers, uri-encode, zlib
      }:
      mkDerivation {
        pname = "Agda";
-       version = "2.6.0.1";
-       sha256 = "1s600ry1qwizr3ynyj05rvlx7jdcw9a1viyc0ycjamm5sjf8mf3v";
+       version = "2.6.1";
+       sha256 = "0af1nyyscdc4gr4l0k3ayq3rn8qxqkx1b7rh4mw023gkz1m433v7";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal directory filepath process ];
        libraryHaskellDepends = [
          aeson array async base binary blaze-html boxes bytestring
-         containers data-hash deepseq directory EdisonCore edit-distance
-         equivalence exceptions filepath geniplate-mirror gitrev hashable
+         containers data-hash deepseq directory edit-distance equivalence
+         exceptions filepath geniplate-mirror ghc-compact gitrev hashable
          hashtables haskeline ieee754 mtl murmur-hash pretty process
-         regex-tdfa split stm strict template-haskell text time
+         regex-tdfa split stm strict template-haskell text time transformers
          unordered-containers uri-encode zlib
        ];
        libraryToolDepends = [ alex happy ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "BinderAnn" = callPackage
+    ({ mkDerivation, base, containers, ghc, ghc-prim, mtl, split, syb
+     , transformers
+     }:
+     mkDerivation {
+       pname = "BinderAnn";
+       version = "0.1.0.0";
+       sha256 = "0fv5xrgqh7scbkzjisrh112zpggwl3rxfjzfqhx2rzdjgda3m41g";
+       libraryHaskellDepends = [
+         base containers ghc ghc-prim mtl split syb transformers
+       ];
+       testHaskellDepends = [
+         base containers ghc ghc-prim mtl split syb transformers
+       ];
+       description = "Source-to-source plugin for enhancing EDSLs with static annotations";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "Binpack" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "HExcel";
-       version = "0.1.0.0";
-       sha256 = "1g761qaqijwsnwinhbk44m967myz7iz8qfz60vhh9fljv89afifg";
+       version = "0.1.0.1";
+       sha256 = "0pa33yh2sqslhdr94bi17kysmf0j3gqhplcxrcafgip2gab9j626";
        libraryHaskellDepends = [
          base microlens microlens-th time transformers
        ];
···
      }:
      mkDerivation {
        pname = "HsWebots";
-       version = "0.1.1.2";
-       sha256 = "02nm89dwm43yg5a99n9x72jf2y61rshqk6ka52s13qsg6d0bvhzv";
+       version = "0.1.1.3";
+       sha256 = "0ddbg63wfjwmrziaq0472iz7yhlcfsh2hrjqj02r1qavba35hzwa";
        libraryHaskellDepends = [
          base bytestring inline-c inline-c-cpp JuicyPixels safe-exceptions
          template-haskell vector
···
      }) {};
 
   "Spintax" = callPackage
-    ({ mkDerivation, attoparsec, base, extra, mtl, mwc-random, text }:
-     mkDerivation {
-       pname = "Spintax";
-       version = "0.3.3";
-       sha256 = "04vb07r26p4rxgsym5zhqsnyx4sr2a112sa31mdda5hjpy9j3pr1";
-       libraryHaskellDepends = [
-         attoparsec base extra mtl mwc-random text
-       ];
-       description = "Random text generation based on spintax";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "Spintax_0_3_4" = callPackage
     ({ mkDerivation, attoparsec, base, extra, mtl, mwc-random, text }:
      mkDerivation {
        pname = "Spintax";
···
        ];
        description = "Random text generation based on spintax";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "Spock" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "aeson_1_4_7_0" = callPackage
+    ({ mkDerivation, attoparsec, base, base-compat
+     , base-compat-batteries, base-orphans, base16-bytestring
+     , bytestring, containers, deepseq, Diff, directory, dlist, filepath
+     , generic-deriving, ghc-prim, hashable, hashable-time
+     , integer-logarithms, primitive, QuickCheck, quickcheck-instances
+     , scientific, tagged, tasty, tasty-golden, tasty-hunit
+     , tasty-quickcheck, template-haskell, text, th-abstraction, time
+     , time-compat, unordered-containers, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "aeson";
+       version = "1.4.7.0";
+       sha256 = "15ykkxa636jnx1zcyq4yxgjz78m5fp315gg0llbjf44jk4fbhndh";
+       libraryHaskellDepends = [
+         attoparsec base base-compat-batteries bytestring containers deepseq
+         dlist ghc-prim hashable primitive scientific tagged
+         template-haskell text th-abstraction time time-compat
+         unordered-containers uuid-types vector
+       ];
+       testHaskellDepends = [
+         attoparsec base base-compat base-orphans base16-bytestring
+         bytestring containers Diff directory dlist filepath
+         generic-deriving ghc-prim hashable hashable-time integer-logarithms
+         QuickCheck quickcheck-instances scientific tagged tasty
+         tasty-golden tasty-hunit tasty-quickcheck template-haskell text
+         time time-compat unordered-containers uuid-types vector
+       ];
+       description = "Fast JSON parsing and encoding";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "aeson-applicative" = callPackage
     ({ mkDerivation, aeson, base, text, unordered-containers }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "aeson-match-qq";
-       version = "1.1.0";
-       sha256 = "0qkj38b05klzwrgy0vyr9qnkllzz9v225b3d60f6mbx3q3nxdk9x";
+       version = "1.2.0";
+       sha256 = "000dna5xs5ybhr4vyla6ndj7ykk7lphg4dbcp7nn13746fnnggs2";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring either haskell-src-meta scientific
          template-haskell text unordered-containers vector
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "algebra-checkers" = callPackage
+    ({ mkDerivation, ansi-terminal, base, checkers, containers, groups
+     , mtl, pretty, QuickCheck, syb, template-haskell
+     , th-instance-reification, transformers
+     }:
+     mkDerivation {
+       pname = "algebra-checkers";
+       version = "0.1.0.0";
+       sha256 = "0phrm0lncqbjqsyxhk3ifmzfb2q42v6g81qklh49n1y73naykg9v";
+       libraryHaskellDepends = [
+         ansi-terminal base checkers containers groups mtl pretty QuickCheck
+         syb template-haskell th-instance-reification transformers
+       ];
+       description = "Model and test API surfaces algebraically";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "algebra-dag" = callPackage
     ({ mkDerivation, aeson, base, containers, fgl, mtl, parsec
      , template-haskell, transformers
···
      }:
      mkDerivation {
        pname = "archive-libarchive";
-       version = "0.2.2.1";
-       sha256 = "1rwvz196m837h5vxm7aqlyzc07h2y2q0czgpn8kwx2gjngpnmmdn";
+       version = "0.2.2.2";
+       sha256 = "12a7rvzbywz5kh403q0q612z1f2arb74jgjx9qk1vdhiyasgwnkh";
        libraryHaskellDepends = [
          base bytestring composition-prelude libarchive
        ];
        libraryToolDepends = [ cpphs ];
        description = "Common interface using libarchive";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "archive-sig" = callPackage
···
      }:
      mkDerivation {
        pname = "arion-compose";
-       version = "0.1.0.0";
-       sha256 = "11jg7y6gcgsm7pidqnpxi4smd5dbm7fnqw79pcqx60z32b0b99iz";
+       version = "0.1.1.0";
+       sha256 = "0d90m39gir2371wgjkkmb7yrqr92zncjr6naz68r64a9mq38ga90";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "Run docker-compose with help from Nix/NixOS";
        license = stdenv.lib.licenses.asl20;
-       maintainers = with stdenv.lib.maintainers; [ roberth ];
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "arith-encode" = callPackage
···
        doHaddock = false;
        description = "A build tool for ATS";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "ats-setup" = callPackage
···
        broken = true;
      }) {};
 
+  "autopack" = callPackage
+    ({ mkDerivation, base, Cabal, dir-traverse, filepath }:
+     mkDerivation {
+       pname = "autopack";
+       version = "0.0.0.0";
+       sha256 = "1z1w6bvsfhnia2dxihcay6a9va2ik1bg805zkfb0vn4vcxn76dcc";
+       libraryHaskellDepends = [ base Cabal dir-traverse filepath ];
+       description = "Custom Setup to automate package modules discovery";
+       license = stdenv.lib.licenses.mpl20;
+     }) {};
+
   "autoproc" = callPackage
     ({ mkDerivation, base, directory, mtl, process, unix }:
      mkDerivation {
···
        pname = "aws-cloudfront-signed-cookies";
        version = "0.2.0.1";
        sha256 = "1yk40n6gjs72pyi6yjwhqj0dngqc4b74rpg0ji61852nbb0snl28";
+       revision = "3";
+       editedCabalFile = "1v0bbyskwbawfhaji3s63hjrzwsi2bb7l8g6yxdp02bp6zb92757";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base hedgehog neat-interpolation ];
        description = "Generate signed cookies for AWS CloudFront";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "aws-cloudfront-signed-cookies_0_2_0_4" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, asn1-encoding, asn1-types
+     , base, base64-bytestring, bytestring, cookie, cryptonite, hedgehog
+     , lens, lens-aeson, neat-interpolation, optparse-applicative, pem
+     , text, time, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "aws-cloudfront-signed-cookies";
+       version = "0.2.0.4";
+       sha256 = "0j40760k1ackwhsy279ir8jybnvis5m56i5hy3rppjybhjiyyd4v";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty asn1-encoding asn1-types base base64-bytestring
+         bytestring cookie cryptonite lens lens-aeson optparse-applicative
+         pem text time unordered-containers vector
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base hedgehog neat-interpolation ];
+       description = "Generate signed cookies for AWS CloudFront";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "aws-cloudfront-signer" = callPackage
···
        ];
        description = "Haskell bindings for Amazon DynamoDB Streams";
        license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-easy" = callPackage
···
        ];
        description = "Helper function and types for working with amazonka";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-ec2" = callPackage
···
        ];
        description = "AWS EC2/VPC, ELB and CloudWatch client library for Haskell";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-ec2-knownhosts" = callPackage
···
        ];
        description = "Bindings for Amazon Web Services (AWS) General Reference";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-kinesis" = callPackage
···
        ];
        description = "Bindings for Amazon Kinesis";
        license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-kinesis-client" = callPackage
···
        ];
        description = "Haskell bindings for AWS Lambda";
        license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-lambda-haskell-runtime" = callPackage
···
        testHaskellDepends = [ base hspec ];
        description = "Haskell runtime for AWS Lambda";
        license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-lambda-runtime" = callPackage
···
        ];
        description = "Amazon Route53 DNS service plugin for the aws package";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-sdk" = callPackage
···
        ];
        description = "The text converter for aws-sdk";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-sdk-xml-unordered" = callPackage
···
        ];
        description = "The xml parser for aws-sdk package";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-ses-easy" = callPackage
···
        ];
        description = "Bindings for AWS SNS Version 2013-03-31";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "axel" = callPackage
···
     ({ mkDerivation, base, base-compat }:
      mkDerivation {
        pname = "base-compat-migrate";
-       version = "0.1.1.0";
-       sha256 = "1k7yjqqc9kd2a1dch33hs3xiyh868a83klx9iz69ix72khacggvk";
+       version = "0.2.0.0";
+       sha256 = "0xc9fjdv4bx5isw39l9aknvwvi46zpc4930wxvsx0v4qa8yhfpaa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base base-compat ];
···
        pname = "brittany";
        version = "0.12.1.1";
        sha256 = "0nw7ymdb7xam634w42l1xjgyvpla8grcg02aj19fscw2fn9gfh7z";
-       revision = "1";
-       editedCabalFile = "0wqg0yl3da1dgpqqv5q0ml3k0njn7pgipaac4vd9gidv3d1pyd74";
+       revision = "2";
+       editedCabalFile = "0pfrm5vvh7x94f8gy8ka6rmq6yk6xxxgba68rd91bk8lbjxsmkxl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "butcher";
        version = "1.3.2.3";
        sha256 = "0lpicayq9k59m2ydz989xsypr653xwhp6mmhlp7nmjzk6jwpq5q5";
-       revision = "1";
-       editedCabalFile = "06vy9018ia6sncgxdmv4ili2krkqn1b6r7xz4raa18kdvgnl100v";
+       revision = "2";
+       editedCabalFile = "1751sllw8s81x3s1dhilbr5lqnv9cpdqiv17c8by466aa6304dxa";
        libraryHaskellDepends = [
          base bifunctors containers deque extra free microlens microlens-th
          mtl multistate pretty transformers unsafe void
···
      }:
      mkDerivation {
        pname = "byline";
-       version = "0.3.2.1";
-       sha256 = "196c75i7cz7yww3d5pi5p51wd5bf3a8v8nsb2vkiv25ndwrsb20w";
-       revision = "1";
-       editedCabalFile = "1bkrhwi851qq6jd3wcajypqi3aha66hsr0jq1h8wgqpgm6mg0abl";
+       version = "0.4.0.0";
+       sha256 = "1q8xb5b194ywm1sacxx47yhicww3m9hpffidgpj6l79fjqivgv09";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "bytes";
        version = "0.17";
        sha256 = "11gacfxcn9f3v5a1phlgi7mwwrnyh51sfsym573g6i4v2zqfrwi3";
+       revision = "1";
+       editedCabalFile = "0pa787mwyic7bhbxpcp2dh86vhdccbdiakxss2c084h8hd8c1g97";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base binary binary-orphans bytestring cereal containers hashable
···
      }:
      mkDerivation {
        pname = "cabal2nix";
-       version = "2.15.0";
-       sha256 = "1xfskgmwr75f1lk8a6mllp2h62jdl7hkwb01r74gpi0n6h17p3nm";
+       version = "2.15.1";
+       sha256 = "1gdwri0x7kw96y0c6j9rdqa68arrxkpisq43ld58applxcvr1cs7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "capability" = callPackage
-    ({ mkDerivation, base, containers, dlist, exceptions, generic-lens
-     , hspec, lens, monad-control, monad-unlift, mtl, mutable-containers
-     , primitive, safe-exceptions, silently, streaming, temporary, text
-     , transformers, unliftio, unliftio-core
+    ({ mkDerivation, base, constraints, containers, dlist, exceptions
+     , generic-lens, hspec, lens, monad-control, monad-unlift, mtl
+     , mutable-containers, primitive, safe-exceptions, silently
+     , streaming, temporary, text, transformers, unliftio, unliftio-core
      }:
      mkDerivation {
        pname = "capability";
-       version = "0.2.0.0";
-       sha256 = "0jssnbqrhkkfkjzya8qprk89r8vqzzy45sm9bwhw2rwx8mrbn40q";
+       version = "0.3.0.0";
+       sha256 = "1kha2y1x63af43psl708c0iib0ign4jrs2n4s2jl4a0pb7hlcdcz";
        libraryHaskellDepends = [
-         base dlist exceptions generic-lens lens monad-control monad-unlift
-         mtl mutable-containers primitive safe-exceptions streaming
-         transformers unliftio unliftio-core
+         base constraints dlist exceptions generic-lens lens monad-control
+         monad-unlift mtl mutable-containers primitive safe-exceptions
+         streaming transformers unliftio unliftio-core
        ];
        testHaskellDepends = [
          base containers hspec lens mtl silently streaming temporary text
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "character-cases" = callPackage
+    ({ mkDerivation, base, containers, doctest, Glob, here, megaparsec
+     , prettyprinter, template-haskell
+     }:
+     mkDerivation {
+       pname = "character-cases";
+       version = "0.1.0.0";
+       sha256 = "1383g5fwy11h43268609n9dmvp0wqwgycn9ly8c7g8h4qpyckh38";
+       libraryHaskellDepends = [
+         base containers here megaparsec prettyprinter template-haskell
+       ];
+       testHaskellDepends = [
+         base containers doctest Glob here megaparsec prettyprinter
+         template-haskell
+       ];
+       description = "Exposes subspecies types of Char. And naming cases. e.g. meaning of [a-z], [A-Z], [0-9], PascalCase, camelCase, and sneak_case.";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "charade" = callPackage
     ({ mkDerivation, base, configurator, containers, filepath, heist
      , lens, mtl, QuickCheck, random, snap, snap-core, snap-extras
···
        ];
        description = "Check properties on standard classes and data structures";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "checkers_0_5_5" = callPackage
+    ({ mkDerivation, array, base, QuickCheck, random, semigroupoids }:
+     mkDerivation {
+       pname = "checkers";
+       version = "0.5.5";
+       sha256 = "1g16603803xzz73md1azlcpd6xz7gkwjpy66l638v6lvipdl9hr9";
+       libraryHaskellDepends = [
+         array base QuickCheck random semigroupoids
+       ];
+       description = "Check properties on standard classes and data structures";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "checkmate" = callPackage
···
      }:
      mkDerivation {
        pname = "cobot-io";
-       version = "0.1.2.7";
-       sha256 = "0gf0amdlkzrar154vmqx952c5p7hbqm6qay47w7m0xb6p2qgvrv7";
+       version = "0.1.2.8";
+       sha256 = "1snq2ypf7blknhpv86xq1n7f6a9pifd77yylsirqj358j590c4i6";
        libraryHaskellDepends = [
          array attoparsec base binary bytestring containers data-msgpack
          deepseq http-conduit hyraxAbif lens linear mtl split text vector
···
      }) {};
 
   "codex" = callPackage
-    ({ mkDerivation, ascii-progress, base, bytestring, Cabal
-     , containers, cryptohash, directory, filepath, hackage-db
-     , http-client, lens, machines, machines-directory, network, process
-     , tar, text, transformers, wreq, yaml, zlib
+    ({ mkDerivation, ascii-progress, base, bytestring, Cabal, conduit
+     , containers, cryptonite, directory, filepath, hackage-db
+     , http-client, http-client-tls, memory, network, process, tar, text
+     , transformers, yaml, zlib
      }:
      mkDerivation {
        pname = "codex";
-       version = "0.5.2.0";
-       sha256 = "1bvz8pzh9qgb7ffnmihcain877igf1hm8rs4z9qx1gckz2c566vv";
-       revision = "1";
-       editedCabalFile = "0v0jlarip2689jxixymqzy36qywla76j78iqzyyc6s7hrd63mrlx";
+       version = "0.6.0.0";
+       sha256 = "1xak07a2sn2fafrng53n8yksf6z73wn2r8paqymmc4385shhmndc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ascii-progress base bytestring Cabal containers cryptohash
-         directory filepath hackage-db http-client lens machines
-         machines-directory process tar text transformers wreq yaml zlib
+         ascii-progress base bytestring Cabal conduit containers cryptonite
+         directory filepath hackage-db http-client memory process tar text
+         transformers yaml zlib
        ];
        executableHaskellDepends = [
-         ascii-progress base Cabal directory filepath hackage-db network
-         process transformers wreq yaml
+         ascii-progress base Cabal directory filepath hackage-db
+         http-client-tls network process transformers yaml
        ];
        description = "A ctags file generator for cabal project dependencies";
        license = stdenv.lib.licenses.asl20;
···
        pname = "compositional-data";
        version = "0.1.0.1";
        sha256 = "1pw7xqzin7v9xxjkm7xixf5d6r5jmgdgyvyhpsmn8bdqp8rrwgzj";
-       revision = "1";
-       editedCabalFile = "167j8vjxv8lf4h92dqag8wdz7k8sp2678s72afs0wig2sy4hm720";
+       revision = "2";
+       editedCabalFile = "1frk7dr9kqk5s4ngni3ygvi1g6g7wlnc6cqhrml3xyj1zj5c8chi";
        libraryHaskellDepends = [
          base bifunctor category transformers util
        ];
···
     ({ mkDerivation, base, containers, random, stm }:
      mkDerivation {
        pname = "concurrent-resource-map";
-       version = "0.1.0.0";
-       sha256 = "05zgjb2plrk35fiyskk07jfiydi4mlk6awbfjvhnsa3qi11pxdly";
-       libraryHaskellDepends = [ base containers ];
-       testHaskellDepends = [ base random stm ];
+       version = "0.2.0.0";
+       sha256 = "1m66x54rvw95gm63nh18w8jcny4r9ri19am870rbnlvb572zxsjz";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base containers random stm ];
        description = "Concurrent resource map";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "concurrent-rpc" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "conduit_1_3_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, directory
+     , exceptions, filepath, gauge, hspec, kan-extensions
+     , mono-traversable, mtl, mwc-random, primitive, QuickCheck
+     , resourcet, safe, silently, split, text, transformers, unix
+     , unliftio, unliftio-core, vector
+     }:
+     mkDerivation {
+       pname = "conduit";
+       version = "1.3.2";
+       sha256 = "0vmcyi3f280b6ll6pcyma4aqrl6m69n6y6x7wplxgsmxz5q7kng3";
+       libraryHaskellDepends = [
+         base bytestring directory exceptions filepath mono-traversable mtl
+         primitive resourcet text transformers unix unliftio-core vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory exceptions filepath hspec
+         mono-traversable mtl QuickCheck resourcet safe silently split text
+         transformers unliftio vector
+       ];
+       benchmarkHaskellDepends = [
+         base containers deepseq gauge hspec kan-extensions mwc-random
+         transformers vector
+       ];
+       description = "Streaming data processing library";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "conduit-algorithms" = callPackage
     ({ mkDerivation, async, base, bytestring, bzlib-conduit, conduit
      , conduit-combinators, conduit-extra, conduit-zstd, containers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "conduit-extra_1_3_5" = callPackage
+    ({ mkDerivation, async, attoparsec, base, bytestring
+     , bytestring-builder, conduit, directory, exceptions, filepath
+     , gauge, hspec, network, primitive, process, QuickCheck, resourcet
+     , stm, streaming-commons, text, transformers, transformers-base
+     , typed-process, unliftio-core
+     }:
+     mkDerivation {
+       pname = "conduit-extra";
+       version = "1.3.5";
+       sha256 = "1n8js1y1rdswvp0bkjmmz19fag19bdxgwsrqz93yc09w43p8sr4a";
+       libraryHaskellDepends = [
+         async attoparsec base bytestring conduit directory filepath network
+         primitive process resourcet stm streaming-commons text transformers
+         typed-process unliftio-core
+       ];
+       testHaskellDepends = [
+         async attoparsec base bytestring bytestring-builder conduit
+         directory exceptions filepath hspec process QuickCheck resourcet
+         stm streaming-commons text transformers transformers-base
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring bytestring-builder conduit gauge transformers
+       ];
+       description = "Batteries included conduit: adapters for common libraries";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "conduit-find" = callPackage
     ({ mkDerivation, attoparsec, base, conduit, conduit-combinators
      , conduit-extra, directory, doctest, either, exceptions, filepath
···
        testHaskellDepends = [ base conferer hedis hspec text ];
        description = "conferer's FromConfig instances for hedis settings";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "conferer-hspec" = callPackage
···
        ];
        description = "Configuration for reading dhall files";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "conferer-provider-json" = callPackage
···
        ];
        description = "Configuration for reading yaml files";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "conferer-snap" = callPackage
···
        ];
        description = "conferer's FromConfig instances for snap Config";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "conferer-warp" = callPackage
···
        testHaskellDepends = [ base hspec hspec-megaparsec megaparsec ];
        description = "Build tool for C";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "cplex-hs" = callPackage
···
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
+     }) {};
+
+  "crypto-token" = callPackage
+    ({ mkDerivation, array, base, cryptonite, memory }:
+     mkDerivation {
+       pname = "crypto-token";
+       version = "0.0.0.0";
+       sha256 = "1azvzzf4w6q76fbggw4f4inqibkvzy9chpdd01349rm8b0nyfh50";
+       libraryHaskellDepends = [ array base cryptonite memory ];
+       description = "crypto tokens";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "crypto-totp" = callPackage
···
     ({ mkDerivation, aeson, base, bytestring }:
      mkDerivation {
        pname = "deriving-aeson";
-       version = "0.2";
-       sha256 = "0d9f4xjczks79vrlw93q7jg32s3ygwl488v6ql8lr4rfvbxzik23";
+       version = "0.2.2";
+       sha256 = "0hv7c9fyfm9zynz5kha1ws0qsizkrcjnwy84lhyixxzlqh3rl16d";
        libraryHaskellDepends = [ aeson base ];
        testHaskellDepends = [ aeson base bytestring ];
        description = "Type driven generic aeson instance customisation";
···
        ];
        description = "Convert between Dhall and YAML";
        license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "dhcp-lease-parser" = callPackage
···
     ({ mkDerivation, base, parsec, random-fu, transformers }:
      mkDerivation {
        pname = "dice";
-       version = "0.1";
-       sha256 = "1rfx3vh983f3gc6si661zimhjl47ip30l3pvf7dysjirr3gffgz1";
+       version = "0.1.0.1";
+       sha256 = "1jybckq3wf3vs0d92ji6a6mlgw64afhwdr6b0w2p1d97zp2fsdn3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parsec random-fu transformers ];
···
      }:
      mkDerivation {
        pname = "dir-traverse";
-       version = "0.2.2.2";
-       sha256 = "0wckqnfmdmfgp7kkvjc2pzg9610xqfnam5myv9xcq04cr3h3dy8g";
+       version = "0.2.2.3";
+       sha256 = "1nn85mfjsg1w3c9bz4f3igkh1ss0927zaqcz5p9qhwsf8f4wqr3x";
        libraryHaskellDepends = [ base directory filepath ];
        benchmarkHaskellDepends = [
          base criterion directory dirstream pipes pipes-safe system-filepath
···
        pname = "dl-fedora";
        version = "0.7.3";
        sha256 = "095wmsflwm4wqlvk2h7s64nqacha8did10av9n52pj3kcwczqx2i";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base bytestring directory filepath http-directory http-types
+         optparse-applicative regex-posix simple-cmd simple-cmd-args text
+         time unix xdg-userdirs
+       ];
+       description = "Fedora image download tool";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "dl-fedora_0_7_4" = callPackage
+    ({ mkDerivation, base, bytestring, directory, filepath
+     , http-directory, http-types, optparse-applicative, regex-posix
+     , simple-cmd, simple-cmd-args, text, time, unix, xdg-userdirs
+     }:
+     mkDerivation {
+       pname = "dl-fedora";
+       version = "0.7.4";
+       sha256 = "092fmla7a0xbnfac6izcj08wsyxbd04n23cjy33c132lqhs5k6w5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "dobutokO2";
-       version = "0.8.2.0";
-       sha256 = "1czji489jj0f18shcx4likz8l46zwvq9vabrn1wv1lyh19nnk1k8";
+       version = "0.15.1.0";
+       sha256 = "1r2zwwcbkm07g1lrypdg3aj4qhyy3g7fds042i4l5abs045aqa2l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "A small, low-dependency library that provides turn-key file download over HTTP and HTTPS";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "dozenal" = callPackage
···
      }:
      mkDerivation {
        pname = "eccrypto";
-       version = "0.2.0";
-       sha256 = "1ng9lin5cavmcrp60lrnqxfkhb5drhlk9nzrl8d6gr1g7zfj75qm";
+       version = "0.2.1";
+       sha256 = "181c8avf0k8377n0z8qm3v7dnqg01z1gp5zwhcrk8khb3h4d4rp7";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bytestring cryptohash-sha512 integer-gmp random
···
     ({ mkDerivation, base, bytestring, eccrypto }:
      mkDerivation {
        pname = "eccrypto-ed25519-bindings";
-       version = "0.1.0.0";
-       sha256 = "1yi93a9x5sl3h50cky7l9df3077kwr3grp2iw9s5iykcwi6jdzg7";
+       version = "0.1.1.0";
+       sha256 = "1yzalib6a5h7k7bhc9kzr2lqhd928yva3j2mxynx3lmw26jc5r17";
        libraryHaskellDepends = [ base bytestring eccrypto ];
        description = "provides \"ed25519\" API using \"eccrypto\"";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "ekg";
        version = "0.4.0.15";
        sha256 = "1k3d5kiqm034qs04k0pcisf4zbdmx2fcgl9a6c1lzzjw96zf6aj8";
-       revision = "6";
-       editedCabalFile = "012y235n8k7hhx651l01xf88vgr2wskapbsn83w18ls1h1njqnzk";
+       revision = "7";
+       editedCabalFile = "1p6mq14si3bqgw4b1frdfj5cbqpz3p399q8wipk6z95yyg129f6i";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring ekg-core ekg-json filepath network snap-core
···
      }:
      mkDerivation {
        pname = "ekg-core";
-       version = "0.1.1.6";
-       sha256 = "0hjprlx99k7mgs2zn06yckir71dvz90xs24g2r990r97mmwxva36";
+       version = "0.1.1.7";
+       sha256 = "04nv6iwzrb63fs97ixb0amj8p6zhabg3ggbrg4nbkq7xjhmkz0a5";
        libraryHaskellDepends = [
          base containers ghc-prim text unordered-containers
        ];
        benchmarkHaskellDepends = [ base ];
        description = "Tracking of system metrics";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "ekg-elastic" = callPackage
···
        pname = "ekg-json";
        version = "0.1.0.6";
        sha256 = "0iyx0ix4dcyhh9xg4ia1lm7x2q0iffswnr33khfg9fr81am80shy";
-       revision = "4";
-       editedCabalFile = "16sn4nbqm0rxkf0swi6r2jn6z9x92qmcg9xlx258d98kqb5fkwjg";
+       revision = "5";
+       editedCabalFile = "0qc3fdycamm97lhhvwgvl8kvj169qrwr5ds4vkvyclpv0s90ijva";
        libraryHaskellDepends = [
          aeson base ekg-core text unordered-containers
        ];
···
        testHaskellDepends = [ base ];
        description = "Easily expose your EKG metrics to Prometheus";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "ekg-push" = callPackage
···
        pname = "ekg-statsd";
        version = "0.2.4.0";
        sha256 = "1nvsiblha1fzykvfaq1s0fyvfmhm32wvxdsfkn9pqd6dl5ivyx2y";
-       revision = "3";
-       editedCabalFile = "0va7fliya7g546f5qbc42bl7dyh74al38sspd2smjyl7a9d5mmlk";
+       revision = "4";
+       editedCabalFile = "0mrar804w2m57zg9bd0qkp4vbkzmgi46478v6z7qcz7qpd8vml9d";
        libraryHaskellDepends = [
          base bytestring ekg-core network text time unordered-containers
        ];
···
      }) {};
 
   "elm-syntax" = callPackage
-    ({ mkDerivation, base, bound, deriving-compat, prettyprinter
-     , protolude, text, unordered-containers
+    ({ mkDerivation, base, bound, deriving-compat, hashable
+     , prettyprinter, text, unordered-containers
      }:
      mkDerivation {
        pname = "elm-syntax";
-       version = "0.2.0.0";
-       sha256 = "1fqfsk3xnvl8j49rarchabvw8lq8mflzyzawq5myi74w1gd6ril8";
+       version = "0.3.0.0";
+       sha256 = "0pv0ly51wpbfr11rng57pasn5sgq7xz986jy36n8qb03q6irvsn9";
        libraryHaskellDepends = [
-         base bound deriving-compat prettyprinter protolude text
+         base bound deriving-compat hashable prettyprinter text
          unordered-containers
        ];
        testHaskellDepends = [
-         base bound deriving-compat prettyprinter protolude text
+         base bound deriving-compat hashable prettyprinter text
          unordered-containers
        ];
        description = "Elm syntax and pretty-printing";
···
   "eventstore" = callPackage
     ({ mkDerivation, aeson, array, async, base, bifunctors, bytestring
      , cereal, clock, connection, containers, dns, dotnet-timespan
-     , ekg-core, exceptions, fast-logger, file-embed, hashable
-     , http-client, interpolate, lifted-async, lifted-base
-     , monad-control, monad-logger, mono-traversable, mtl, protobuf
-     , random, safe, safe-exceptions, semigroups, stm, stm-chans
-     , streaming, tasty, tasty-hspec, tasty-hunit, text, time
-     , transformers-base, unordered-containers, uuid, vector
+     , exceptions, fast-logger, file-embed, hashable, http-client
+     , interpolate, lifted-async, lifted-base, monad-control
+     , monad-logger, mono-traversable, mtl, protobuf, random, safe
+     , safe-exceptions, semigroups, stm, stm-chans, streaming, tasty
+     , tasty-hspec, tasty-hunit, text, time, transformers-base
+     , unordered-containers, uuid, vector
      }:
      mkDerivation {
        pname = "eventstore";
-       version = "1.3.3";
-       sha256 = "0xf67ywg2f1wj75s82s2lsi2zgvk1xqhl09c4hnl45qzslkbl2xp";
+       version = "1.4.0";
+       sha256 = "0p7xfvdm4bjdp23f1ikfyq1gbylxav6b3wmbxhmscmzai396al12";
        libraryHaskellDepends = [
          aeson array base bifunctors bytestring cereal clock connection
-         containers dns dotnet-timespan ekg-core exceptions fast-logger
-         hashable http-client interpolate lifted-async lifted-base
-         monad-control monad-logger mono-traversable mtl protobuf random
-         safe safe-exceptions semigroups stm stm-chans streaming text time
+         containers dns dotnet-timespan exceptions fast-logger hashable
+         http-client interpolate lifted-async lifted-base monad-control
+         monad-logger mono-traversable mtl protobuf random safe
+         safe-exceptions semigroups stm stm-chans streaming text time
          transformers-base unordered-containers uuid vector
        ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "extensible";
-       version = "0.7.1";
-       sha256 = "1vmn2ziv8qnw22pkfy1c80hym7cprv70xz0mqi5076glwdjkx3gr";
+       version = "0.8";
+       sha256 = "1p5mnzk4x6dk8gyr3n47wlndnqf8w7112whr872355zqyvcxlsq6";
        libraryHaskellDepends = [
          aeson base bytestring cassava comonad constraints deepseq ghc-prim
          hashable membership monad-skeleton prettyprinter primitive
···
      }:
      mkDerivation {
        pname = "faktory";
-       version = "1.0.1.0";
-       sha256 = "0vkg1siaiq6dj1i0dnfdcdswr7fw4shn92wyfj8lxrj6krmfjrni";
+       version = "1.0.1.1";
+       sha256 = "1wz7f1ai73xc5n06db8mjbmbdyf5r9p78ysx3q1yiq32h2mvjd3m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "fb_2_1_0" = callPackage
+  "fb_2_1_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit
      , conduit-extra, containers, cryptonite, data-default, hspec
      , http-client, http-conduit, http-types, HUnit, memory
···
      }:
      mkDerivation {
        pname = "fb";
-       version = "2.1.0";
-       sha256 = "18h16dkyh35q0wyjvri7z2q2j8rx4bb6ma2bf6h2cdm7jh6zdakq";
+       version = "2.1.1";
+       sha256 = "0j2rckrv1aksfp2wyiyffqg40jl927vs97fk2lyzkscz673jd9s9";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring conduit conduit-extra cryptonite
          data-default http-client http-conduit http-types memory
···
        pname = "ffunctor";
        version = "1.2.0";
        sha256 = "0rq60a7ximvqdxqvijw1isd1d5gwqbjagmws91y0jvxlwmsgzf6w";
+       revision = "1";
+       editedCabalFile = "0biwzy37ig69s7l4x2cp0p71w3fn1azfd81vsj39fzn4kpcrpgld";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [
          aeson base exceptions generic-lens http-client mtl servant
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "free-categories_0_2_0_0" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "free-categories";
+       version = "0.2.0.0";
+       sha256 = "0932bvy2cgmancjy4invm9m16w27kawlfmd3zy9xi8sl9a62rp38";
+       libraryHaskellDepends = [ base ];
+       description = "free categories";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "free-category" = callPackage
     ({ mkDerivation, base, criterion, free-algebras, QuickCheck, tasty
      , tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "front";
-       version = "0.0.0.3";
-       sha256 = "0n2w3rcl20njqrxx9ws2jrw3yjrxhxzl6q916apyh07bricmmkw9";
+       version = "0.0.0.5";
+       sha256 = "0gn5lrh817r9ky8j4kzrqdlisiy85gr6v7nyd2sj1psa8syrjfzk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "fusion-plugin" = callPackage
-    ({ mkDerivation, base, ghc, syb }:
-     mkDerivation {
-       pname = "fusion-plugin";
-       version = "0.1.1";
-       sha256 = "15bjjsxck6682nva7mahss87rxlzw8j66hzkhji122swyvgd89a1";
-       libraryHaskellDepends = [ base ghc syb ];
-       description = "GHC plugin to make stream fusion more predictable";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "fusion-plugin_0_2_0" = callPackage
     ({ mkDerivation, base, fusion-plugin-types, ghc, syb }:
      mkDerivation {
        pname = "fusion-plugin";
···
        description = "GHC plugin to make stream fusion more predictable";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "fusion-plugin-types" = callPackage
···
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.14.1";
-       sha256 = "1bg0r9b0jg9j12lcc6wa684yjm58l020m9x5abpc54cghigywswj";
-       revision = "1";
-       editedCabalFile = "0iqg18jz8lgbh9iq1zgs8j9q5smzzi8w1asryz4dx8y6dl7n97p5";
+       version = "0.15.1";
+       sha256 = "181kgqbdqxcim16ld68wx09lr4gh0j9440lnn2lyzrzmn8a9567w";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "genvalidity_0_10_0_2" = callPackage
+    ({ mkDerivation, base, hspec, hspec-core, QuickCheck, random
+     , validity
+     }:
+     mkDerivation {
+       pname = "genvalidity";
+       version = "0.10.0.2";
+       sha256 = "1k6pba9zal7385838b9w9ybhk5742jwfy8bqa921zi08mv7vgqlp";
+       libraryHaskellDepends = [ base QuickCheck random validity ];
+       testHaskellDepends = [ base hspec hspec-core QuickCheck ];
+       description = "Testing utilities for the validity library";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "genvalidity-aeson" = callPackage
     ({ mkDerivation, aeson, base, genvalidity, genvalidity-hspec
      , genvalidity-scientific, genvalidity-text
···
      }:
      mkDerivation {
        pname = "ghc-lib-parser-ex";
-       version = "8.8.5.3";
-       sha256 = "0svjfrsq7r1hvpjp0bk4jqq9z6gm441hsv5zb1yljw9p9b20kbk6";
+       version = "8.8.5.6";
+       sha256 = "0jwndkf7idpf09zrj4i4x1vsyfpm0vf85vlh00qp0z3avqcxsf2m";
        libraryHaskellDepends = [
          base bytestring containers extra ghc ghc-boot ghc-boot-th uniplate
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib-parser-ex_8_8_5_5" = callPackage
+  "ghc-lib-parser-ex_8_8_5_8" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, extra
      , filepath, ghc, ghc-boot, ghc-boot-th, tasty, tasty-hunit
      , uniplate
      }:
      mkDerivation {
        pname = "ghc-lib-parser-ex";
-       version = "8.8.5.5";
-       sha256 = "15rp1829zzppz3y014cac1ssmklssn5hsfvadqrzkzmnky2yr215";
+       version = "8.8.5.8";
+       sha256 = "1mw1ym5bn39z7lqmxnhhkfqb0kbxddabkafw025wgs54knsghvmk";
        libraryHaskellDepends = [
          base bytestring containers extra ghc ghc-boot ghc-boot-th uniplate
        ];
···
      }) {};
 
   "ghc-tags-plugin" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers
-     , directory, filepath, ghc, lattices, QuickCheck
-     , quickcheck-instances, tasty, tasty-golden, tasty-quickcheck, text
+    ({ mkDerivation, attoparsec, base, bytestring, directory, filelock
+     , filepath, ghc, lattices, QuickCheck, quickcheck-instances, tasty
+     , tasty-golden, tasty-quickcheck, text
      }:
      mkDerivation {
        pname = "ghc-tags-plugin";
-       version = "0.1.4.0";
-       sha256 = "0ci82krwqiprh23p316n1k09z6ja962xscnx9ycqpsyywbgkcqk4";
+       version = "0.1.5.0";
+       sha256 = "065i5xdf5i0xxj8q2aah2p9n30n65w0r60rfd49bih1iisfk0ljn";
        libraryHaskellDepends = [
-         attoparsec base bytestring containers directory filepath ghc text
+         attoparsec base bytestring directory filelock filepath ghc text
        ];
        testHaskellDepends = [
          attoparsec base bytestring lattices QuickCheck quickcheck-instances
···
        doHaddock = false;
        description = "A compiler plugin which generates tags file from GHC syntax tree";
        license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "ghc-tcplugins-extra" = callPackage
···
      }:
      mkDerivation {
        pname = "ghc-typelits-natnormalise";
-       version = "0.7.1";
-       sha256 = "1sbwzbs3bnvyla44kcsxs6h12sdfqzbm6n0swy2scp5p271fr0i3";
-       libraryHaskellDepends = [
-         base containers ghc ghc-tcplugins-extra integer-gmp syb
-         transformers
-       ];
-       testHaskellDepends = [ base tasty tasty-hunit template-haskell ];
-       description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
-       license = stdenv.lib.licenses.bsd2;
-     }) {};
-
-  "ghc-typelits-natnormalise_0_7_2" = callPackage
-    ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra
-     , integer-gmp, syb, tasty, tasty-hunit, template-haskell
-     , transformers
-     }:
-     mkDerivation {
-       pname = "ghc-typelits-natnormalise";
        version = "0.7.2";
        sha256 = "1hk2f2vqkpia7kv7pqwf942y1w9m7mvmikzabkrjp8f8gijcsk52";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base tasty tasty-hunit template-haskell ];
        description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
        license = stdenv.lib.licenses.bsd2;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "ghc-typelits-presburger" = callPackage
···
      }:
      mkDerivation {
        pname = "ghcid";
-       version = "0.8.1";
-       sha256 = "1k5yk9ba6g2x0wsqx1zb9zviqp9p7myd628fxi2rf4wjh0kkjc4c";
+       version = "0.8.3";
+       sha256 = "1b8a8mx6z2ridw79gijjv90b2jgk0qrncvg0sjbmvyyyajx1h5f7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "ghcid_0_8_3" = callPackage
+  "ghcid_0_8_5" = callPackage
     ({ mkDerivation, ansi-terminal, base, cmdargs, containers
      , directory, extra, filepath, fsnotify, process, tasty, tasty-hunit
      , terminal-size, time, unix
      }:
      mkDerivation {
        pname = "ghcid";
-       version = "0.8.3";
-       sha256 = "1b8a8mx6z2ridw79gijjv90b2jgk0qrncvg0sjbmvyyyajx1h5f7";
+       version = "0.8.5";
+       sha256 = "15zj78wasix4yz8mxx5hl6x1gj364vsbwn5arp7sbq13rywhs2qy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, criterion, hedgehog }:
      mkDerivation {
        pname = "grab";
-       version = "0.0.0.1";
-       sha256 = "1jsi8g538w4a441w412siqvrkzmvx8sff74nax93b5paiaqfwcrf";
+       version = "0.0.0.4";
+       sha256 = "0yanm9ak2sw266wn9lllz086g53sra7xfncpql6403d2lj3j1jj4";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hedgehog ];
        benchmarkHaskellDepends = [ base criterion ];
···
     ({ mkDerivation, base, containers, grab, hedgehog, text }:
      mkDerivation {
        pname = "grab-form";
-       version = "0.0.0.2";
-       sha256 = "1mi21d3p7jwmwmn69f7xy6zkks0w11kkwwvzmhxsd84zsafnis8k";
+       version = "0.0.0.4";
+       sha256 = "0ch8c0kfjky9s1ilrxyr27jhmvynrp61imb188rc3fv7yfr0b5n5";
        libraryHaskellDepends = [ base containers grab text ];
        testHaskellDepends = [ base containers hedgehog text ];
        description = "Applicative parsers for form parameter lists";
···
        pname = "graph";
        version = "0.0.0.0";
        sha256 = "1v94nii7q6smm37m3yk390mcxpa69qclxqqdzcmay8f096dzk3pd";
+       revision = "1";
+       editedCabalFile = "0ij8sdnz3k6lfsvl5wvr4dl8njjlmpl3fai8fybvs0b2yhnr6v49";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ];
        description = "Class of graphs";
···
     ({ mkDerivation, base, containers, random }:
      mkDerivation {
        pname = "hanabi-dealer";
-       version = "0.7.0.0";
-       sha256 = "0a62h0mblddp77binl73h8yq46r9szrqzdvx16zawb0y222d14mp";
+       version = "0.7.1.1";
+       sha256 = "1agh5sq0hj9r55w3k529jcar66p4vih54j5w3h28chm34n9k6qa2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers random ];
···
      }:
      mkDerivation {
        pname = "hasbolt";
-       version = "0.1.4.2";
-       sha256 = "0qrfdfyzm61zaxd9m7s93zhrr2qjpgyn24l3gbyll2v8yj38j5rm";
+       version = "0.1.4.3";
+       sha256 = "1sfnr6qrv95ryf6c4hpj3vj8v6y64qjjd2fnz4x9i37win9wcb1z";
        libraryHaskellDepends = [
          base binary bytestring connection containers data-binary-ieee754
          data-default mtl network text
···
     ({ mkDerivation, base, haskell-src-exts }:
      mkDerivation {
        pname = "haskell-src-exts-simple";
-       version = "1.22.0.0";
-       sha256 = "1zfb12r7fpq5nnfgn27m8grql2bx50w7g2jbgy9404rjcr1gk59c";
+       version = "1.23.0.0";
+       sha256 = "1jfdjaikmjx9sfairp4jjn0vzhw5vhwrg43y082ddpc1bgx2jw7m";
        libraryHaskellDepends = [ base haskell-src-exts ];
        description = "A simplified view on the haskell-src-exts AST";
        license = stdenv.lib.licenses.mit;
···
      }) {};
 
   "haskell-to-elm" = callPackage
-    ({ mkDerivation, aeson, base, bound, elm-syntax, generics-sop
-     , protolude, text, time, unordered-containers
+    ({ mkDerivation, aeson, base, bound, elm-syntax, generics-sop, text
+     , time, unordered-containers
      }:
      mkDerivation {
        pname = "haskell-to-elm";
-       version = "0.2.1.0";
-       sha256 = "0a6h1hmfkwhi6yfbzb71yifmhvapbnrlwj5yp0kjp88nr1cnh69h";
+       version = "0.3.0.0";
+       sha256 = "02gspfwiif3a38fsfv0pxia7lcqyqppf9pnrbirnqdcry721mcvy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base bound elm-syntax generics-sop protolude text time
+         aeson base bound elm-syntax generics-sop text time
          unordered-containers
        ];
        testHaskellDepends = [
-         aeson base bound elm-syntax generics-sop protolude text time
+         aeson base bound elm-syntax generics-sop text time
          unordered-containers
        ];
        description = "Generate Elm types and JSON encoders and decoders from Haskell types";
···
        testToolDepends = [ hspec-discover ];
        description = "Bitcoin & Bitcoin Cash library for Haskell";
        license = stdenv.lib.licenses.publicDomain;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "haskoin-crypto" = callPackage
···
        broken = true;
      }) {};
 
+  "hasql-notifications" = callPackage
+    ({ mkDerivation, base, bytestring, contravariant, hasql, hasql-pool
+     , hspec, postgresql-libpq, QuickCheck, text
+     }:
+     mkDerivation {
+       pname = "hasql-notifications";
+       version = "0.1.0.0";
+       sha256 = "18pix0fmbcf8l45q78w33vjyxxbp5c0gvqxdc9bhvkfhn0cl5q0i";
+       revision = "1";
+       editedCabalFile = "11crw51y45laxaidj615g7mlmp5igdxd5w35pmddb82xpg915ccs";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring contravariant hasql hasql-pool postgresql-libpq
+         text
+       ];
+       executableHaskellDepends = [ base hasql ];
+       testHaskellDepends = [ base bytestring hasql hspec QuickCheck ];
+       description = "LISTEN/NOTIFY support for Hasql";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "hasql-optparse-applicative" = callPackage
     ({ mkDerivation, base-prelude, hasql, hasql-pool
      , optparse-applicative
···
      }:
      mkDerivation {
        pname = "hasql-th";
-       version = "0.4.0.4";
-       sha256 = "1kd12vw98wml58sp1dqfq58z0vjjqdssb6q7f6ngs7q6ig27kxfb";
+       version = "0.4.0.5";
+       sha256 = "1gc11n2g07cqipcvm779wwm36mfjjbnwg9n1ch7cldlg1wsr6m6n";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers contravariant
          fast-builder foldl hashable hasql headed-megaparsec megaparsec
···
        ];
        description = "Template Haskell utilities for Hasql";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "hasql-transaction" = callPackage
···
      }:
      mkDerivation {
        pname = "headed-megaparsec";
-       version = "0.1.0.2";
-       sha256 = "0npkkphm4gv7cgm08asr5qxjyk6jdbm4h4w0jwsvxzpxh3nfxgbr";
+       version = "0.1.0.4";
+       sha256 = "1nl66j4fqmjcxkrmhm7jnbqqpw48727wfbb9xn0cz4yy1brivjrb";
        libraryHaskellDepends = [
          base case-insensitive megaparsec parser-combinators selective
        ];
        description = "More informative parser";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "headergen" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "higher-leveldb_0_6_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, data-default, exceptions
+     , hspec, leveldb-haskell, mtl, process, resourcet, transformers
+     , transformers-base, unliftio, unliftio-core
+     }:
+     mkDerivation {
+       pname = "higher-leveldb";
+       version = "0.6.0.0";
+       sha256 = "0gsqf92vp92a0jl3nchm40mxi5k7hnm7wjczhpkq0akka6b7ciy7";
+       revision = "2";
+       editedCabalFile = "1g8fnqvxjcq332wrnls272ff8grcbrc875phm77nsmjb8q4wjqz7";
+       libraryHaskellDepends = [
+         base bytestring cereal data-default exceptions leveldb-haskell mtl
+         resourcet transformers transformers-base unliftio-core
+       ];
+       testHaskellDepends = [
+         base bytestring cereal hspec leveldb-haskell mtl process resourcet
+         transformers transformers-base unliftio
+       ];
+       description = "A rich monadic API for working with leveldb databases";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "higherorder" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "hledger";
-       version = "1.17";
-       sha256 = "1rdafl9c1z16ci3b812aaic6sbh1292dh5n3xqpnaqx9g68w71d4";
-       revision = "1";
-       editedCabalFile = "1lkg0h8hc7m0lj0hzylc3paiip2d6a6k9k37289gdynrm04nj258";
+       version = "1.17.1.1";
+       sha256 = "17c7g4xnwkbi77drqc6w96bp2lw0b86yg1qmm0gsdnli2m93baz4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "A pie chart image generator for the hledger accounting tool";
        license = "GPL";
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "hledger-diff" = callPackage
···
      }:
      mkDerivation {
        pname = "hledger-interest";
-       version = "1.5.3";
-       sha256 = "1ff113z2ir07ihdvfa5fca4x326zwm2jd7sjy6hjpr4qgi1mszvs";
-       revision = "1";
-       editedCabalFile = "1myqv7hci32hvm98d4fn2zqdvkxsdx1g821n1fwr6814yn89kwjj";
+       version = "1.5.4";
+       sha256 = "0n3pjd86j43dprpsy1k9x72v8g46dhy3f9244hvwhigyx72ijm6h";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "computes the internal rate of return of an investment";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "hledger-lib" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, array, base
      , base-compat-batteries, blaze-markup, bytestring, call-stack
      , cassava, cassava-megaparsec, cmdargs, containers, data-default
-     , Decimal, deepseq, directory, extra, fgl, file-embed, filepath
-     , Glob, hashtables, megaparsec, mtl, old-time, parsec
+     , Decimal, deepseq, directory, doctest, extra, fgl, file-embed
+     , filepath, Glob, hashtables, megaparsec, mtl, old-time, parsec
      , parser-combinators, pretty-show, regex-tdfa, safe, split, tabular
      , tasty, tasty-hunit, template-haskell, text, time, timeit
      , transformers, uglymemo, utf8-string
      }:
      mkDerivation {
        pname = "hledger-lib";
-       version = "1.17.0.1";
-       sha256 = "0kmwrkm4arhzzcfh4dhmikad1kfkv9y5dc58mjhi1jacdiy980r9";
+       version = "1.17.1";
+       sha256 = "19vny2l2l45dk0fkpi2lzpzaj7jks2r0zjv8dkpcxlyk8bvqi92c";
        libraryHaskellDepends = [
          aeson ansi-terminal array base base-compat-batteries blaze-markup
          bytestring call-stack cassava cassava-megaparsec cmdargs containers
···
        testHaskellDepends = [
          aeson ansi-terminal array base base-compat-batteries blaze-markup
          bytestring call-stack cassava cassava-megaparsec cmdargs containers
-         data-default Decimal deepseq directory extra fgl file-embed
+         data-default Decimal deepseq directory doctest extra fgl file-embed
          filepath Glob hashtables megaparsec mtl old-time parsec
          parser-combinators pretty-show regex-tdfa safe split tabular tasty
          tasty-hunit template-haskell text time timeit transformers uglymemo
···
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
+  "hledger-stockquotes" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
+     , hedgehog, hledger-lib, req, safe, scientific, split, tasty
+     , tasty-hedgehog, tasty-hunit, text, time, unordered-containers
+     }:
+     mkDerivation {
+       pname = "hledger-stockquotes";
+       version = "0.1.0.0";
+       sha256 = "19xn7rzrg4nw1dfdfm1hn7k0wdwrw8416rn28inkbkbn1f9mqgk5";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers hledger-lib req safe scientific
+         split text time unordered-containers
+       ];
+       executableHaskellDepends = [ base bytestring cmdargs text time ];
+       testHaskellDepends = [
+         base hedgehog tasty tasty-hedgehog tasty-hunit
+       ];
+       description = "Generate HLedger Price Directives From Daily Stock Quotes";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hledger-ui" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, base-compat-batteries
      , brick, cmdargs, containers, data-default, directory, extra
···
      }:
      mkDerivation {
        pname = "hledger-ui";
-       version = "1.17";
-       sha256 = "1168h7lc6r61gpaiy07l9dp534hggnlvdcx3a2lmjx4m29ym1frz";
+       version = "1.17.1.1";
+       sha256 = "0cwjjcy4r6dy1w4svmi7jk1yrp654qr8ic33ipg24dh7bl6lqzps";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "A curses-style console interface for the hledger accounting tool";
        license = "GPL";
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "hledger-web" = callPackage
···
      }:
      mkDerivation {
        pname = "hledger-web";
-       version = "1.17";
-       sha256 = "15flyvaamr7r3dlzk9ihc3bv8z15myfrzzhlbpc5s3gy6q85lmay";
+       version = "1.17.1";
+       sha256 = "0zcb7a8xchsb093sw9aq30n45rns9v0xknwvigds3ka8yb383krl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hlrdb";
-       version = "0.3.0.0";
-       sha256 = "0pc3hqi6v9b78fijisnarfs59w6mw8jgyww25r1wmblgwyakl5ab";
-       revision = "1";
-       editedCabalFile = "1ycglx3b5n1l97pq0rd50wd313gwz1is10snf8s0c9bjlrzspbn5";
+       version = "0.3.1.0";
+       sha256 = "19sxpyv331sjldanf40gw598gcj98n9xwc985cz9k2m38ck3vwhr";
        libraryHaskellDepends = [
          base base64-bytestring bytestring cryptonite hashable hedis
          hlrdb-core memory random store time unordered-containers
···
      }:
      mkDerivation {
        pname = "hopenpgp-tools";
-       version = "0.23";
-       sha256 = "1sgqx8b1sq89hpjzbdmkjsmrfagh5v0jfxyqphzkh1bq2zydj0jl";
+       version = "0.23.1";
+       sha256 = "0jq1if7c78758fnsb6wxsky0jn9mhmzwhb5jpyrpigx08diwd2mj";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hs-server-starter";
-       version = "0.1.0.2";
-       sha256 = "1fykxrhh6s2w722jknz87in3ni3a9spjhbbrqm1vw5r5mcsv29gh";
+       version = "0.1.1.0";
+       sha256 = "1cki3c6fl7yjw9vww4h9vd68dnci5q8f5c1i3ip8kyv53s9rgbi3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory network ];
···
      }:
      mkDerivation {
      , Only, should-not-typecheck, single-tuple, text
-       version = "0.6.4";
-     , Only, should-not-typecheck, single-tuple, text
-       libraryHaskellDepends = [
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-         time transformers
-       ];
-       testHaskellDepends = [
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-       ];
-       doCheck = false;
-     , Only, should-not-typecheck, single-tuple, text
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     }:
-     mkDerivation {
-     , Only, should-not-typecheck, single-tuple, text
      , Only, should-not-typecheck, single-tuple, text
      , Only, should-not-typecheck, single-tuple, text
        libraryHaskellDepends = [
···
        doCheck = false;
      , Only, should-not-typecheck, single-tuple, text
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
      , Only, should-not-typecheck, single-tuple, text
···
      }) {};
 
      , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , xml-conduit
-     }:
-     mkDerivation {
-     , Only, should-not-typecheck, single-tuple, text
-       version = "0.1.7";
-     , Only, should-not-typecheck, single-tuple, text
-       libraryHaskellDepends = [
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-       ];
-       testHaskellDepends = [ base hspec text ];
-     , Only, should-not-typecheck, single-tuple, text
-       license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
-     }) {};
-
-     , Only, should-not-typecheck, single-tuple, text
      , Only, should-not-typecheck, single-tuple, text
      , Only, should-not-typecheck, single-tuple, text
      , xml-conduit
···
      }:
      mkDerivation {
      , Only, should-not-typecheck, single-tuple, text
-       version = "1.1.0.0";
-     , Only, should-not-typecheck, single-tuple, text
+       version = "1.2.0.0";
+       sha256 = "07abw78ds4fb4y8c7x94fpwcab58b2k613b3dk8hh9qqplhgl8ms";
        libraryHaskellDepends = [
      , Only, should-not-typecheck, single-tuple, text
      , Only, should-not-typecheck, single-tuple, text
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-     , Only, should-not-typecheck, single-tuple, text
+  "hvega_0_7_0_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
      , Only, should-not-typecheck, single-tuple, text
      }:
      mkDerivation {
      , Only, should-not-typecheck, single-tuple, text
-       version = "0.6.0.0";
-     , Only, should-not-typecheck, single-tuple, text
+       version = "0.7.0.0";
+       sha256 = "0kj40mm5d809adblk74h0k57qqpk8jxl5bhildasjzjfmmr4spax";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ aeson base text unordered-containers ];
···
      , Only, should-not-typecheck, single-tuple, text
      , Only, should-not-typecheck, single-tuple, text
        license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     }:
-     mkDerivation {
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-       libraryHaskellDepends = [
-     , Only, should-not-typecheck, single-tuple, text
-         vector
-       ];
-       testHaskellDepends = [
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-     , Only, should-not-typecheck, single-tuple, text
-     , Only, should-not-typecheck, single-tuple, text
-       license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
      , Only, should-not-typecheck, single-tuple, text
···
        pname = "hyraxAbif";
        version = "0.2.3.21";
        sha256 = "0ghhfv8gzs9sg13nj3mhqd24zbrkjj1dgsjz3sql6276kpa1p2kc";
+       revision = "1";
+       editedCabalFile = "0rg4wldliyaixmgcyina2cnm7l6gwpcdd2bim1q83clnfk32scar";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hz3";
        version = "96.0.0.0";
        sha256 = "080bhbnhswic7m35rzbqi9i7lb57szag6khprrjccpa80vq7lj6n";
-       revision = "2";
-       editedCabalFile = "02q1pcy6z4vl1qm4klw17aqx577v7c4jsl4b5r5iw6293arym8fz";
+       revision = "3";
+       editedCabalFile = "0dm62xr708ps7dsln41cxsn4m4a5093dpq8xrp6hyss4mrzg8hz0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers transformers ];
···
        ];
        description = "A fast JSON document store with push notification support";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
+       maintainers = with stdenv.lib.maintainers; [ rkrzr ];
      }) {};
 
   "icon-fonts" = callPackage
···
     ({ mkDerivation, aeson, base, hvega, ihaskell, text }:
      mkDerivation {
        pname = "ihaskell-hvega";
-       version = "0.2.3.0";
-       sha256 = "02j08ci3ss82g2a26qdnykwb1rggb8w53jqm4xnxc8hqm25fb3mk";
+       version = "0.2.4.0";
+       sha256 = "0yk8wxr1kh3xibb1l5jgjryq7h4id9cz59yjkjjzq41r6p1zr6yj";
        libraryHaskellDepends = [ aeson base hvega ihaskell text ];
        description = "IHaskell display instance for hvega types";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "incremental" = callPackage
-    ({ mkDerivation, aeson, base, containers, deepseq, extensible
+    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
      , semigroups, text
      }:
      mkDerivation {
        pname = "incremental";
-       version = "0.1.1";
-       sha256 = "17lwakfa7xh0rdxr4hixlqy9hldvz06hcsclw3kln7m4iv4843d7";
+       version = "0.2";
+       sha256 = "0af3nrjmhxzn6q45nvrw8lw54239pkwdl3fdvhj10fv8rxdihnzh";
        libraryHaskellDepends = [
-         aeson base containers deepseq extensible semigroups text
+         aeson base bytestring containers deepseq semigroups text
        ];
        testHaskellDepends = [ base ];
        description = "incremental update library";
···
      }:
      mkDerivation {
        pname = "incremental-parser";
-       version = "0.4";
-       sha256 = "0iyprnyk66zdyi21632d0aznvzk7i0hmr3idq49yjilxwck2xac4";
-       libraryHaskellDepends = [
-         base monoid-subclasses parsers rank2classes transformers
-       ];
-       testHaskellDepends = [
-         base checkers monoid-subclasses QuickCheck tasty tasty-quickcheck
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion deepseq monoid-subclasses text
-       ];
-       description = "Generic parser library capable of providing partial results from partial input";
-       license = stdenv.lib.licenses.gpl3;
-     }) {};
-
-  "incremental-parser_0_4_0_1" = callPackage
-    ({ mkDerivation, base, bytestring, checkers, criterion, deepseq
-     , monoid-subclasses, parsers, QuickCheck, rank2classes, tasty
-     , tasty-quickcheck, text, transformers
-     }:
-     mkDerivation {
-       pname = "incremental-parser";
        version = "0.4.0.1";
        sha256 = "1cghkzdsh8vjv1ggk5qjr5ny88wna5kbifbfsy1ld5n5k66536lf";
        libraryHaskellDepends = [
···
        ];
        description = "Generic parser library capable of providing partial results from partial input";
        license = stdenv.lib.licenses.gpl3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "incremental-sat-solver" = callPackage
···
        pname = "intro";
        version = "0.6.0.1";
        sha256 = "1kka6dnlyqppjx9ykk3zixfyslr8cf4ja6sa2hgq6h69mmsicp67";
-       revision = "1";
-       editedCabalFile = "1jxd4agavzccgszniqzakgpb6b49qx5c20asr068rpvaf03msncx";
+       revision = "2";
+       editedCabalFile = "12jmy4lp9yrix6hm6cx3kmgprpmlwdyxqckyx53h01iygfpbx3w5";
        libraryHaskellDepends = [
          base bytestring containers deepseq dlist extra hashable mtl safe
          text transformers unordered-containers writer-cps-mtl
···
      }) {};
 
   "ipfs" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, data-has, directory
-     , directory-tree, doctest, envy, flow, Glob, http-client, ip, lens
-     , lens-aeson, monad-logger, QuickCheck, regex-compat, rio
-     , servant-client, servant-client-core, servant-multipart
-     , servant-server, swagger2, text, vector, yaml
+    ({ mkDerivation, aeson, base, bytestring, directory, directory-tree
+     , doctest, envy, flow, Glob, ip, lens, lens-aeson, monad-logger
+     , QuickCheck, regex-compat, rio, servant-client, servant-server
+     , swagger2, text, vector, yaml
      }:
      mkDerivation {
        pname = "ipfs";
-       version = "1.0.1";
-       sha256 = "1k4ybm99gbwnv1crx8y8fggf9iv1f1g49x3zvypji7n1zgx84b1r";
+       version = "1.0.2";
+       sha256 = "0mrr67bz283qqz0d70j9gz191l4pi554j3hmcf7pscg87b84rdv5";
        libraryHaskellDepends = [
-         aeson base bytestring data-has envy flow Glob http-client ip lens
-         monad-logger regex-compat rio servant-client servant-client-core
-         servant-multipart servant-server swagger2 text vector
+         aeson base bytestring envy flow Glob ip lens monad-logger
+         regex-compat rio servant-client servant-server swagger2 text vector
        ];
        testHaskellDepends = [
-         aeson base bytestring data-has directory directory-tree doctest
-         envy flow Glob http-client ip lens lens-aeson monad-logger
-         QuickCheck regex-compat rio servant-client servant-client-core
-         servant-multipart servant-server swagger2 text vector yaml
+         aeson base bytestring directory directory-tree doctest envy flow
+         Glob ip lens lens-aeson monad-logger QuickCheck regex-compat rio
+         servant-client servant-server swagger2 text vector yaml
        ];
        description = "Access IPFS locally and remotely";
        license = stdenv.lib.licenses.agpl3Plus;
···
        ];
        description = "IP Routing Table";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "iproute_1_7_9" = callPackage
+    ({ mkDerivation, appar, base, byteorder, bytestring, containers
+     , doctest, hspec, network, QuickCheck, safe
+     }:
+     mkDerivation {
+       pname = "iproute";
+       version = "1.7.9";
+       sha256 = "1m306fi39ifqq53sklwn81q96wam8nvx7mr5hv4m9f26kiczlism";
+       libraryHaskellDepends = [
+         appar base byteorder bytestring containers network
+       ];
+       testHaskellDepends = [
+         appar base byteorder bytestring containers doctest hspec network
+         QuickCheck safe
+       ];
+       description = "IP Routing Table";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "iptables-helpers" = callPackage
···
      }:
      mkDerivation {
        pname = "ixset-typed";
-       version = "0.4.0.1";
-       sha256 = "135cfc8d39qv02sga03gsym1yfajf0l5ci1s6q9n1xpb9ignblx8";
-       revision = "1";
-       editedCabalFile = "0kfklsbjn4gmx76vl7vm1s149f13h2p537930yaq8s2671lzc79p";
+       version = "0.5";
+       sha256 = "07n7qfi8slmrlgzvrkddr17b792phhb140q9gb5pm68kk1im4izs";
        libraryHaskellDepends = [
          base containers deepseq safecopy syb template-haskell
        ];
···
        testHaskellDepends = [ base parsec tasty tasty-hunit text ];
        description = "Handle Jira wiki markup";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "jira-wiki-markup_1_1_3" = callPackage
+    ({ mkDerivation, base, mtl, parsec, tasty, tasty-hunit, text }:
+     mkDerivation {
+       pname = "jira-wiki-markup";
+       version = "1.1.3";
+       sha256 = "1hr67awpl1zpwp53x9b6ix4gdfq8r77r9wnm44qc9q91q8i872wv";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base mtl parsec text ];
+       executableHaskellDepends = [ base text ];
+       testHaskellDepends = [ base parsec tasty tasty-hunit text ];
+       description = "Handle Jira wiki markup";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "jmacro" = callPackage
···
        pname = "kansas-comet";
        version = "0.4";
        sha256 = "1q9rffh6589a5am8mvfzxzwws34vg08rdjxggfabhmg9y9jla6hz";
-       revision = "18";
-       editedCabalFile = "0yxgndvrashc0cp3zv39gjrzw7p53g0k51p13q67nqnpxhh05w2k";
+       revision = "19";
+       editedCabalFile = "0pnfhv3dlg9cs98nyz5kqdi5mq340909id8rb4lcdj9748w8gz4w";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base containers data-default-class scotty stm text time
···
      }:
      mkDerivation {
        pname = "launchdarkly-server-sdk";
-       version = "1.0.1";
-       sha256 = "1425n7b587k9c6w3k95lcdhk5blj9blzjgnb67ylr1fizzayxc7h";
+       version = "1.0.2";
+       sha256 = "1psm449p7fsh4b5mf7y7dlgh44za1fhf0cbn0qya1j4imy3x673b";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring
          bytestring-conversion clock containers cryptohash exceptions extra
···
        ];
        description = "Haskell interface to libarchive";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) libarchive;};
 
   "libarchive-conduit" = callPackage
···
     ({ mkDerivation, base, containers, doctest, hedgehog }:
      mkDerivation {
        pname = "loc";
-       version = "0.1.3.4";
-       sha256 = "1xdqnqr4wy3xw9vyfkf6c8xsq74nryhb8z31grcwpn6ppdgzyqy2";
+       version = "0.1.3.6";
+       sha256 = "0bspclskqk0kzvic8y4bxagjrfzxpq53xgr0jfp6rcqacql6qvdr";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers doctest hedgehog ];
        description = "Types representing line and column positions and ranges in text files";
···
     ({ mkDerivation, base, containers, hedgehog, loc }:
      mkDerivation {
        pname = "loc-test";
-       version = "0.1.3.4";
-       sha256 = "1lzmyxm34zvkdz3piwmnhd7m0ijjnlwqbpi5lgbqvbrikbw579qp";
+       version = "0.1.3.6";
+       sha256 = "0kzr7adk85y9fcibi8rw7ix3vp2z17ig211lw820nirhwb8xj697";
        libraryHaskellDepends = [ base containers hedgehog loc ];
        description = "Test-related utilities related to the /loc/ package";
        license = stdenv.lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "lzlib";
-       version = "1.0.4.0";
-       sha256 = "1l7mbxh2cn8vgfxwkzrz9mv5ca2bx4ymbswvjz7b3mgjx0wiy9g8";
+       version = "1.0.6.0";
+       sha256 = "1qirn7kbcnxx6ihhk0r6p2jyfbs8cqsinfnmn774i3vkj1fahpn1";
        libraryHaskellDepends = [ base bytestring ];
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [
···
        ];
        description = "A toolkit for working with macaroons";
        license = stdenv.lib.licenses.isc;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "macbeth-lib" = callPackage
···
     ({ mkDerivation, base, comonad, HTF, MonadRandom }:
      mkDerivation {
        pname = "markov-realization";
-       version = "0.3.3";
-       sha256 = "1w6rj8l40ajb5nmh3mlf99n526a17w7q9vnyn6x3j9sn0sm4csl3";
+       version = "0.4";
+       sha256 = "1kkydk71yhzf2q82vzal6npfs022a5x2ynj95l835kn1lh2n3vhm";
        libraryHaskellDepends = [ base comonad MonadRandom ];
-       testHaskellDepends = [ base HTF ];
+       testHaskellDepends = [ base HTF MonadRandom ];
        description = "Realizations of Markov chains";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "massiv_0_5_0_0" = callPackage
+  "massiv_0_5_1_0" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, cabal-doctest
      , data-default-class, deepseq, doctest, exceptions
      , mersenne-random-pure64, primitive, QuickCheck, random, scheduler
···
      }:
      mkDerivation {
        pname = "massiv";
-       version = "0.5.0.0";
-       sha256 = "09hyrlhcvqrhsmyl7lsm9qmp8yshia1jmjh2bqlsnw8xvwg2z13a";
+       version = "0.5.1.0";
+       sha256 = "062b9mg1nqsg7lfv4a85s994jg1fipikpvxdb9w6ci3dqiq41dx0";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bytestring data-default-class deepseq exceptions primitive
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "matrix-sized" = callPackage
+    ({ mkDerivation, base, binary, bytestring, deepseq, primitive
+     , singletons, vector
+     }:
+     mkDerivation {
+       pname = "matrix-sized";
+       version = "0.0.2";
+       sha256 = "1sp9d3pfkq80klwryvggjf76hm4y9qqair3cppvgnp06kn99k1z1";
+       libraryHaskellDepends = [
+         base binary bytestring deepseq primitive singletons vector
+       ];
+       description = "Haskell matrix library with interface to C++ linear algebra libraries";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "matrix-static" = callPackage
     ({ mkDerivation, base, deepseq, ghc-typelits-natnormalise, matrix
      , tasty, tasty-hunit, vector
···
        ];
        description = "Terminal client for the Mattermost chat system";
        license = stdenv.lib.licenses.bsd3;
-       maintainers = with stdenv.lib.maintainers; [ kiwi ];
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "mattermost-api" = callPackage
···
        ];
        description = "Client API for Mattermost chat system";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "mattermost-api-qc" = callPackage
···
        ];
        description = "QuickCheck instances for the Mattermost client API library";
        license = stdenv.lib.licenses.isc;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "maude" = callPackage
···
        pname = "monad-choice";
        version = "0.1.0.0";
        sha256 = "0vhfiqrnkfhqkhnh9h4npl3rfam321iikabr3przywfcfd4gap4z";
-       revision = "1";
-       editedCabalFile = "19acnk2dy5zan230g268nyvdx1y8piav3x9z6jsjbi2d7zm9sr38";
+       revision = "3";
+       editedCabalFile = "055zzzz9ag1wb79bjx0wg59plajym156hz0bh0lq4ndvn4k7sxay";
        libraryHaskellDepends = [
          base invariant MonadRandom mtl transformers
        ];
···
        broken = true;
      }) {};
 
+  "mr-env" = callPackage
+    ({ mkDerivation, base, hspec }:
+     mkDerivation {
+       pname = "mr-env";
+       version = "0.1.0.1";
+       sha256 = "102m1gqjcscwf620jpaz1i7hg73ikd19an2wjgnfpfrlzw83xgd6";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec ];
+       description = "A simple way to read environment variables in Haskell";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "mrifk" = callPackage
     ({ mkDerivation, array, base, containers, mtl }:
      mkDerivation {
···
      }) {};
 
   "musicScroll" = callPackage
-    ({ mkDerivation, async, base, bytestring, containers, dbus, gi-gtk
-     , gi-gtk-hs, gtk3, mtl, req, stm, tagsoup, text, transformers
+    ({ mkDerivation, async, base, bytestring, containers, cryptonite
+     , dbus, deepseq, directory, gi-gtk, gi-gtk-hs, gtk3, mtl, req
+     , sqlite-simple, stm, tagsoup, text, transformers, xdg-basedir
      }:
      mkDerivation {
        pname = "musicScroll";
-       version = "0.1.2.0";
-       sha256 = "0n0s9vkhfwykghniillih5qgdz4cg1rn4vn86hinxaqfgzv6m96w";
+       version = "0.2.0.0";
+       sha256 = "1iv80yhal5f8klsc095yabq7402w45j8lb0g64avdyp2zy569vmx";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         async base bytestring containers dbus gi-gtk gi-gtk-hs mtl req stm
-         tagsoup text transformers
+         async base bytestring containers cryptonite dbus deepseq directory
+         gi-gtk gi-gtk-hs mtl req sqlite-simple stm tagsoup text
+         transformers xdg-basedir
        ];
        executableHaskellDepends = [ base ];
        executablePkgconfigDepends = [ gtk3 ];
···
     ({ mkDerivation, base, containers, template-haskell }:
      mkDerivation {
        pname = "names-th";
-       version = "0.3.0.0";
-       sha256 = "09m5zflpk1h7jwz40mijhnpbsd8qnnay1jm3lpfrvdmg49m8zqqb";
+       version = "0.3.0.1";
+       sha256 = "12ally0n6ixsxj0zwbvw439dbx29phvh0rd6l5sd0c5a514a32aa";
        libraryHaskellDepends = [ base containers template-haskell ];
        description = "Manipulate name strings for TH";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "netwire-input-glfw";
-       version = "0.0.10";
-       sha256 = "1r186xwr5lycs0snr8amvyxvbq2l5jd9p20v8n12zyjm60kmi90y";
+       version = "0.0.11";
+       sha256 = "1sizk0c8mbm6ad984gaf933h1bg4dgwi9k8hzrm9wp5rwbqjvcz8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "nix-diff";
-       version = "1.0.8";
-       sha256 = "0073802yrd5f1zfhnbsll9cqcycihw9bac1psfwvcwvihsh3j413";
+       version = "1.0.9";
+       sha256 = "0gqrx0l6f10gwsz645dby2gascd0sanajvd2rkg65c61g8j7pxv4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "nixfmt";
        version = "0.4.0";
        sha256 = "1ispgl8rc2scr6v8bb6sks7px856jf61x74zj2iyddrn5qamkb3n";
+       revision = "1";
+       editedCabalFile = "1hsj0jh6siph3afd9c2wii09sffl48rzqv653n4clpd8qy0rn48d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "om-actor" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "om-actor";
+       version = "0.1.0.0";
+       sha256 = "1wiasb3f22g47n54jhxv1c74a0ghxsknrakjdgj3fqlw878g3aan";
+       libraryHaskellDepends = [ base ];
+       description = "Actor pattern utilities";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "om-elm" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, directory
      , http-types, safe, safe-exceptions, template-haskell, text, unix
···
        ];
        description = "Monad transformer providing MonadFail";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "omaketex" = callPackage
···
          base http-client http-types opentelemetry text
        ];
        license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "opentelemetry-lightstep" = callPackage
···
        sha256 = "1n27g8xjij05g7xxx8z50k39nmclhm707xs2pfqy830zdq1ldfl4";
        libraryHaskellDepends = [ base http-types opentelemetry text wai ];
        license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "opentheory" = callPackage
···
      }) {};
 
   "org-mode" = callPackage
-    ({ mkDerivation, base, filepath, hashable, megaparsec
-     , parser-combinators, tasty, tasty-hunit, text, time
+    ({ mkDerivation, base, containers, filepath, hashable, megaparsec
+     , parser-combinators, tasty, tasty-hunit, text
      }:
      mkDerivation {
        pname = "org-mode";
-       version = "1.0.1";
-       sha256 = "0nhpb8x11w0w3jwplk3bx9a2llw77l66wbm31bpgdpr6ak2r0z75";
+       version = "1.1.0";
+       sha256 = "1k8k24wkvjflrg5bcv6i4ypak5m0k20hrh0gxf5c23y5s4b9dmz5";
        libraryHaskellDepends = [
-         base filepath hashable megaparsec parser-combinators text time
+         base containers filepath hashable megaparsec parser-combinators
+         text
        ];
-       testHaskellDepends = [
-         base megaparsec tasty tasty-hunit text time
-       ];
+       testHaskellDepends = [ base megaparsec tasty tasty-hunit text ];
+       description = "Parser for Emacs org-mode files";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "org-mode-lucid" = callPackage
-    ({ mkDerivation, base, hashable, lucid, org-mode, text }:
+    ({ mkDerivation, base, containers, hashable, lucid, org-mode, text
+     }:
      mkDerivation {
        pname = "org-mode-lucid";
-       version = "1.1.0";
-       sha256 = "066mdm9a7dkz6yy9g2yhqalvxrxhak1mw0awag3ivswv6djf528q";
-       libraryHaskellDepends = [ base hashable lucid org-mode text ];
+       version = "1.2.0";
+       sha256 = "1y7dxm3g7jzq7y45z1d4k1j4rsfjdg4l8gk1ykn5frigwf01vwkf";
+       libraryHaskellDepends = [
+         base containers hashable lucid org-mode text
+       ];
+       description = "Lucid integration for org-mode";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "orgstat";
-       version = "0.1.7";
-       sha256 = "1yvzs6sdkdgi5gfdgznnz1f03sf57icnn7bb5njcam7gxwvswbkp";
+       version = "0.1.8";
+       sha256 = "072xdy9kg853l7lskm1knkk63pnyqh44s7zakplb37x46rcsj4jc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "pantry";
-       version = "0.4.0.0";
-       sha256 = "11n0xrk5258inzzikbapsv7752396qsrgaaf5kimpzgb67cs9k5j";
+       version = "0.4.0.1";
+       sha256 = "182aiwwgrsdj9f4x71q1grj674d91djp4q6bz2l51ly5dsjy5wbf";
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring Cabal casa-client casa-types
          conduit conduit-extra containers cryptonite cryptonite-conduit
···
        pname = "parsers-megaparsec";
        version = "0.1.0.1";
        sha256 = "1fgxnxv5ispf7zg40fa35f1n7x7mk1pc8r96sbqpjbzasga79rx8";
+       revision = "1";
+       editedCabalFile = "16a7h16lq27930l0hpa8z97b4p6cwrz3wdxs67mfxvz2ndngm87d";
        libraryHaskellDepends = [
          base fail megaparsec mtl parsers semigroups text transformers
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "persistable-record_0_6_0_5" = callPackage
+    ({ mkDerivation, array, base, containers, dlist, names-th
+     , product-isomorphic, quickcheck-simple, template-haskell
+     , th-bang-compat, th-constraint-compat, th-data-compat
+     , transformers
+     }:
+     mkDerivation {
+       pname = "persistable-record";
+       version = "0.6.0.5";
+       sha256 = "1jm8270c7805alxa8q8pa5ql9f1ah3ns3p910j86h4bjnvgbvyqa";
+       libraryHaskellDepends = [
+         array base containers dlist names-th product-isomorphic
+         template-haskell th-bang-compat th-constraint-compat th-data-compat
+         transformers
+       ];
+       testHaskellDepends = [ base quickcheck-simple ];
+       description = "Binding between SQL database values and haskell records";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "persistable-types-HDBC-pg" = callPackage
     ({ mkDerivation, base, bytestring, convertible, dlist, HDBC
      , persistable-record, relational-query, relational-query-HDBC
···
        ];
        description = "Backend for the persistent library using postgresql";
        license = stdenv.lib.licenses.mit;
-       maintainers = with stdenv.lib.maintainers; [ psibi ];
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "persistent-protobuf" = callPackage
···
 
   "pkgtreediff" = callPackage
     ({ mkDerivation, async, base, directory, filepath, Glob
-     , http-directory, simple-cmd, simple-cmd-args, text
+     , http-client, http-client-tls, http-directory, simple-cmd
+     , simple-cmd-args, text
      }:
      mkDerivation {
        pname = "pkgtreediff";
-       version = "0.3";
-       sha256 = "0n39cn75cdxzk39hn6fiimb7rm1qrvksmqidy5fgnx997y78z8s9";
+       version = "0.4";
+       sha256 = "00cah2sbfx824zvg4ywm3qw8rkibflj9lmw1z0ywsalgdmmlp460";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         async base directory filepath Glob http-directory simple-cmd
-         simple-cmd-args text
+         async base directory filepath Glob http-client http-client-tls
+         http-directory simple-cmd simple-cmd-args text
        ];
        description = "Package tree diff tool";
        license = stdenv.lib.licenses.gpl3;
···
   "plaid" = callPackage
     ({ mkDerivation, aeson, base, bytestring, casing, conduit
      , conduit-extra, containers, either, errors, hspec, hspec-wai
-     , hspec-wai-json, http-client, http-client-tls, http-conduit
-     , http-types, microlens, microlens-th, mtl, network, pretty-simple
-     , QuickCheck, raw-strings-qq, safe-exceptions, text, time
-     , transformers, wai
+     , http-client, http-client-tls, http-conduit, http-types, microlens
+     , microlens-th, mtl, network, pretty-simple, QuickCheck
+     , raw-strings-qq, safe-exceptions, text, time, transformers, wai
      }:
      mkDerivation {
        pname = "plaid";
-       version = "0.1.0.0";
-       sha256 = "125427rhy5xlaw3qinrazyyj39z4g0rbnhm2k4jrgp1jgba91lc3";
+       version = "0.1.0.4";
+       sha256 = "1mwwd3mnj45l1487hfhb8lhgcvik88qch7vzgk17zv77ginnifni";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          safe-exceptions text time transformers
        ];
        testHaskellDepends = [
-         aeson base bytestring containers errors hspec hspec-wai
-         hspec-wai-json http-types microlens microlens-th pretty-simple
-         QuickCheck text time wai
+         aeson base bytestring containers errors hspec hspec-wai http-types
+         microlens microlens-th pretty-simple QuickCheck text time wai
        ];
        description = "Plaid.com api integration library";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "polynom";
        version = "0.1.0.0";
        sha256 = "1cggjbmyas3bzcs81falp50wq649nhvgxwhhnyk434s0k2h2chwh";
+       revision = "1";
+       editedCabalFile = "0nfrlp48rgw96bpms30d9s2qmhjmbgxszprh2xi73pmjddk26qg3";
        libraryHaskellDepends = [
          algebra base base-unicode-symbols containers
        ];
···
 
   "postgres-websockets" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring
-     , containers, contravariant, either, envparse, hasql, hasql-pool
-     , hspec, hspec-wai, hspec-wai-json, http-types, jose, jwt, lens
-     , lens-aeson, postgresql-libpq, protolude, retry, stm
+     , containers, contravariant, either, envparse, hasql
+     , hasql-notifications, hasql-pool, hspec, hspec-wai, hspec-wai-json
+     , http-types, jose, lens, postgresql-libpq, protolude, retry, stm
      , stm-containers, stringsearch, text, time, transformers
      , unordered-containers, wai, wai-app-static, wai-extra
      , wai-websockets, warp, websockets
      }:
      mkDerivation {
        pname = "postgres-websockets";
-       version = "0.5.0.1";
-       sha256 = "0afhrzhixy0f31050jb04w8np6935wcl3j7ckbk0dm23mqz2z3zy";
+       version = "0.6.0.0";
+       sha256 = "0m9fypc216qcsx596sizgxjv30w08fpfpjglmcias88ri4n3ggy5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base bytestring contravariant either hasql hasql-pool
-         http-types jose jwt lens lens-aeson postgresql-libpq protolude
-         retry stm stm-containers stringsearch text time
-         unordered-containers wai wai-websockets websockets
+         aeson base bytestring contravariant either hasql
+         hasql-notifications hasql-pool http-types jose lens
+         postgresql-libpq protolude retry stm stm-containers stringsearch
+         text time unordered-containers wai wai-websockets websockets
        ];
        executableHaskellDepends = [
          base base64-bytestring bytestring envparse hasql hasql-pool
          protolude text time transformers wai wai-app-static wai-extra warp
        ];
        testHaskellDepends = [
-         aeson base containers hasql hasql-pool hspec hspec-wai
-         hspec-wai-json http-types protolude stm unordered-containers
-         wai-extra
+         aeson base containers hasql hasql-notifications hasql-pool hspec
+         hspec-wai hspec-wai-json http-types protolude stm
+         unordered-containers wai-extra
        ];
        description = "Middleware to map LISTEN/NOTIFY messages to Websockets";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "process_1_6_8_0" = callPackage
+  "process_1_6_8_2" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, directory, filepath
      , unix
      }:
      mkDerivation {
        pname = "process";
-       version = "1.6.8.0";
-       sha256 = "07vl1j66xya4wqm3h42lpkhshpmz90b68r93i2766zhsnx0ryr5r";
+       version = "1.6.8.2";
+       sha256 = "1gdz227gmpax92xmwrvj9nrylybh4kk7m4yqr8qwa9i34dg1jzqx";
        libraryHaskellDepends = [ base deepseq directory filepath unix ];
        testHaskellDepends = [ base bytestring directory ];
        description = "Process libraries";
···
      }:
      mkDerivation {
        pname = "prosidy";
-       version = "1.6.0.0";
-       sha256 = "19c8kz6kdd2flzi1gyddi4yp4fn62wfjahcp66saydb4ipxdxfs4";
+       version = "1.6.0.1";
+       sha256 = "1yd36sjs342may33fbrpzgaghql03wjgprbllkms8pr6d16z8m49";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base binary bytestring containers contravariant deepseq
···
        doCheck = false;
        description = "PureScript Programming Language Compiler";
        license = stdenv.lib.licenses.bsd3;
-       maintainers = with stdenv.lib.maintainers; [ cdepillabout ];
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "purescript-bridge" = callPackage
···
        broken = true;
      }) {};
 
+  "pvar" = callPackage
+    ({ mkDerivation, async, base, deepseq, genvalidity, hspec
+     , primitive, QuickCheck
+     }:
+     mkDerivation {
+       pname = "pvar";
+       version = "0.1.1.0";
+       sha256 = "1fzcv2bzm9hf879a6vcgcsmyjn4fhpl9smz8phi6bq1acfzkg026";
+       libraryHaskellDepends = [ base deepseq primitive ];
+       testHaskellDepends = [
+         async base deepseq genvalidity hspec primitive QuickCheck
+       ];
+       description = "Mutable variable with primitive values";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "pvd" = callPackage
     ({ mkDerivation, array, base, Codec-Image-DevIL, containers
      , haskell98, libdevil, mtl, network, stm, X11
···
      }) {};
 
   "quickcheck-state-machine" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, base, bytestring, containers
-     , directory, doctest, exceptions, filelock, filepath, http-client
-     , matrix, monad-logger, mtl, network, persistent
-     , persistent-postgresql, persistent-template, pretty-show, process
-     , QuickCheck, quickcheck-instances, random, resourcet, servant
-     , servant-client, servant-server, strict, string-conversions, tasty
-     , tasty-hunit, tasty-quickcheck, text, tree-diff, unliftio, vector
-     , wai, warp
+    ({ mkDerivation, aeson, ansi-wl-pprint, array, base, bifunctors
+     , bytestring, containers, directory, doctest, exceptions, filelock
+     , filepath, generic-data, graphviz, hashable, hashtables, hs-rqlite
+     , HTTP, http-client, markov-chain-usage-model, matrix, monad-logger
+     , mtl, network, persistent, persistent-postgresql
+     , persistent-sqlite, persistent-template, postgresql-simple
+     , pretty-show, process, QuickCheck, quickcheck-instances, random
+     , resource-pool, resourcet, servant, servant-client, servant-server
+     , sop-core, split, stm, strict, string-conversions, tasty
+     , tasty-hunit, tasty-quickcheck, text, time, tree-diff, unliftio
+     , unliftio-core, vector, wai, warp
      }:
      mkDerivation {
        pname = "quickcheck-state-machine";
-       version = "0.6.0";
-       sha256 = "0zbjap2jjd534w6cigi4xz34x3f6w8icvxyvxs35j61c52cp2pry";
+       version = "0.7.0";
+       sha256 = "053fc1hxkpfpmwn5dq5x5vd094g978hwc145qpzknwbk6hrc28ka";
        libraryHaskellDepends = [
-         ansi-wl-pprint base containers exceptions matrix mtl pretty-show
-         QuickCheck tree-diff unliftio vector
+         ansi-wl-pprint base containers directory exceptions filepath
+         generic-data graphviz markov-chain-usage-model matrix mtl
+         pretty-show process QuickCheck random sop-core split text time
+         tree-diff unliftio
        ];
        testHaskellDepends = [
-         base bytestring containers directory doctest filelock filepath
-         http-client matrix monad-logger mtl network persistent
-         persistent-postgresql persistent-template pretty-show process
-         QuickCheck quickcheck-instances random resourcet servant
-         servant-client servant-server strict string-conversions tasty
-         tasty-hunit tasty-quickcheck text tree-diff unliftio vector wai
-         warp
+         aeson array base bifunctors bytestring containers directory doctest
+         filelock filepath hashable hashtables hs-rqlite HTTP http-client
+         monad-logger mtl network persistent persistent-postgresql
+         persistent-sqlite persistent-template postgresql-simple pretty-show
+         process QuickCheck quickcheck-instances random resource-pool
+         resourcet servant servant-client servant-server split stm strict
+         string-conversions tasty tasty-hunit tasty-quickcheck text time
+         tree-diff unliftio unliftio-core vector wai warp
        ];
        description = "Test monadic programs using state machine based models";
        license = stdenv.lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
+  "rampart" = callPackage
+    ({ mkDerivation, base, criterion, hspec }:
+     mkDerivation {
+       pname = "rampart";
+       version = "1.0.0.2";
+       sha256 = "17apaldhpqwz8xdnjvz9lwsdlhpvad5107xw5d4v6ql8zvjgz0yw";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec ];
+       benchmarkHaskellDepends = [ base criterion ];
+       description = "🏰 Determine how intervals relate to each other";
+       license = stdenv.lib.licenses.isc;
+     }) {};
+
   "ramus" = callPackage
     ({ mkDerivation, base, criterion, hspec, QuickCheck, quickcheck-io
      }:
···
      }:
      mkDerivation {
        pname = "random-fu";
-       version = "0.2.7.3";
-       sha256 = "071b3gi88kmrfiy6kyz1x67mqljwqb4l45vzg1rc2zig3iwy66ih";
+       version = "0.2.7.4";
+       sha256 = "13dgx069lvdfxm7l2q2l6d7q0gd3wp41b8l4l6wmhlfbl5xici3m";
        libraryHaskellDepends = [
          base erf math-functions monad-loops mtl random-shuffle
          random-source rvar syb template-haskell transformers vector
···
 
   "random-source" = callPackage
     ({ mkDerivation, base, flexible-defaults, mersenne-random-pure64
-     , mtl, mwc-random, random, stateref, syb, template-haskell
-     , th-extras
+     , mtl, mwc-random, primitive, random, stateref, syb
+     , template-haskell, th-extras
      }:
      mkDerivation {
        pname = "random-source";
-       version = "0.3.0.6";
-       sha256 = "0wsv41kpswqml04ym5bq2nan4i637f7h3fmvda2zy506xwxfrpzk";
+       version = "0.3.0.8";
+       sha256 = "0kjvpmxhff6id99hhgjp3vvb4vlhs3shkrh1n5cbfm7450lpmmn2";
        libraryHaskellDepends = [
-         base flexible-defaults mersenne-random-pure64 mtl mwc-random random
-         stateref syb template-haskell th-extras
+         base flexible-defaults mersenne-random-pure64 mtl mwc-random
+         primitive random stateref syb template-haskell th-extras
        ];
        description = "Generic basis for random number generators";
        license = stdenv.lib.licenses.publicDomain;
···
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "9.0.8";
-       sha256 = "1a98zy1n6dlxxyfdganqfcx8hw04i4hjwdj8ggdd4g0jky62jaz2";
+       version = "9.0.9";
+       sha256 = "1i638s8q0vnwkn1s2gwdz98p28vg9rmlz0hc24maks80vbyjraba";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "rebase_1_6" = callPackage
+  "rebase_1_6_0_1" = callPackage
     ({ mkDerivation, base, bifunctors, bytestring, comonad, containers
      , contravariant, contravariant-extras, deepseq, dlist, either
      , hashable, mtl, profunctors, scientific, selective, semigroupoids
···
      }:
      mkDerivation {
        pname = "rebase";
-       version = "1.6";
-       sha256 = "1hsfff3rsaigjcg8s7mvipi68xqx4ala1zdrghgyb76z1c23m6iw";
+       version = "1.6.0.1";
+       sha256 = "0w0vy4y2v09a9v8qjqcxq5nqrdk8c1mw7lak9mwv16j59bcijn0x";
        libraryHaskellDepends = [
          base bifunctors bytestring comonad containers contravariant
          contravariant-extras deepseq dlist either hashable mtl profunctors
···
        pname = "refined";
        version = "0.4.4";
        sha256 = "1xld5fc3nzsr43agvdlv0hbdbnrrsgy0n2a7mfrcc0n3s6rjbdcw";
+       revision = "1";
+       editedCabalFile = "184w9aj60hxm2bq9n29zakqzhi0kf4dqj7cwib31vilpwd0vgfvx";
        libraryHaskellDepends = [
          aeson base deepseq exceptions mtl prettyprinter QuickCheck
          template-haskell transformers
···
      }:
      mkDerivation {
        pname = "reflex";
-       version = "0.6.4";
-       sha256 = "162gjk11z6yjdwnb7y9xhg6h851wxssz9zb548h52hdld9vdfkcf";
+     , Only, should-not-typecheck, single-tuple, text
+       sha256 = "0zm5jgjn4r59h8r0180mkmfnggqv4mgg52vqfwpnz20dv942wzcb";
        libraryHaskellDepends = [
          base bifunctors comonad constraints-extras containers data-default
          dependent-map dependent-sum exception-transformers haskell-src-exts
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "relational-query_0_12_2_3" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, dlist
+     , names-th, persistable-record, product-isomorphic
+     , quickcheck-simple, sql-words, template-haskell, text
+     , th-constraint-compat, th-reify-compat, time, time-locale-compat
+     , transformers
+     }:
+     mkDerivation {
+       pname = "relational-query";
+       version = "0.12.2.3";
+       sha256 = "0zjqk0gkzdhg1l8rw0bz7iwvp55p585xaqp8dc3sbbr0abhmsgi5";
+       libraryHaskellDepends = [
+         array base bytestring containers dlist names-th persistable-record
+         product-isomorphic sql-words template-haskell text
+         th-constraint-compat th-reify-compat time time-locale-compat
+         transformers
+       ];
+       testHaskellDepends = [
+         base containers product-isomorphic quickcheck-simple transformers
+       ];
+       description = "Typeful, Modular, Relational, algebraic query engine";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "relational-query-HDBC" = callPackage
     ({ mkDerivation, base, containers, convertible, dlist, HDBC
      , HDBC-session, names-th, persistable-record, product-isomorphic
···
        ];
        description = "RDBMSs' schema templates for relational-query";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "relational-schemas_0_1_8_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, relational-query
+     , sql-words, template-haskell, time
+     }:
+     mkDerivation {
+       pname = "relational-schemas";
+       version = "0.1.8.0";
+       sha256 = "012b3jqxpyv41vwxvrk6nxall7hvbczkxwmld3w3jzg20z0535l4";
+       libraryHaskellDepends = [
+         base bytestring containers relational-query sql-words
+         template-haskell time
+       ];
+       description = "RDBMSs' schema templates for relational-query";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "relative-date" = callPackage
···
      }:
      mkDerivation {
        pname = "reqcatcher";
-       version = "0.2.1.0";
-       sha256 = "1fh9p7437czn7rw5jmpxlmg0zhrkkj5hwd0kzlr2jainxzvlw2b3";
+       version = "0.2.2.0";
+       sha256 = "0wiazimb8vpsdxrh012hczcxfapxyggq3p54f6lvcljmggh2ncdw";
        libraryHaskellDepends = [ base http-types network text wai warp ];
        testHaskellDepends = [
          base http-client http-types HUnit lens tasty tasty-hunit wai wreq
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "rerebase_1_6" = callPackage
+  "rerebase_1_6_0_1" = callPackage
     ({ mkDerivation, rebase }:
      mkDerivation {
        pname = "rerebase";
-       version = "1.6";
-       sha256 = "0g2bgh30ra006w4ypsrnyvfwys4ajg2b0k6c55snci12acs2igzd";
+       version = "1.6.0.1";
+       sha256 = "07ddcmm2yx71nvgcbj87skrx5pfzsqhi87dxn7vv41ssibv714fk";
        libraryHaskellDepends = [ rebase ];
        description = "Reexports from \"base\" with a bunch of other standard libraries";
        license = stdenv.lib.licenses.mit;
···
        broken = true;
      }) {};
 
+  "retrie" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
+     , data-default, deepseq, directory, filepath, ghc, ghc-exactprint
+     , ghc-paths, haskell-src-exts, HUnit, mtl, optparse-applicative
+     , process, random-shuffle, syb, tasty, tasty-hunit, temporary, text
+     , transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "retrie";
+       version = "0.1.0.0";
+       sha256 = "0x8mc4w6w1pr8k9cmhnb4wad2brqj37qfhkg1vm47zmv3r5sza3s";
+       revision = "1";
+       editedCabalFile = "1gxd78fpn7pw30k0p70vgrr82qcbq4397fk41c4i7rb7m0y4kk3j";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-terminal async base bytestring containers data-default
+         directory filepath ghc ghc-exactprint haskell-src-exts mtl
+         optparse-applicative process random-shuffle syb text transformers
+         unordered-containers
+       ];
+       executableHaskellDepends = [ base data-default ];
+       testHaskellDepends = [
+         base containers data-default deepseq directory filepath ghc
+         ghc-paths HUnit mtl optparse-applicative process syb tasty
+         tasty-hunit temporary text unordered-containers
+       ];
+       description = "A powerful, easy-to-use codemodding tool for Haskell";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "retry" = callPackage
     ({ mkDerivation, base, exceptions, ghc-prim, hedgehog, HUnit, mtl
      , random, stm, tasty, tasty-hedgehog, tasty-hunit, time
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "RISC-V";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "risc386" = callPackage
···
        testHaskellDepends = [ base hspec text ];
        description = "Recurrence rule parser and formatter";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "rsagl" = callPackage
···
      }:
      mkDerivation {
        pname = "rvar";
-       version = "0.2.0.3";
-       sha256 = "1h3bii1pamkv7656280i6zx7fpdwgbn2ysfijpd2s65szlpsz2np";
-       revision = "1";
-       editedCabalFile = "1ifwwjlhc3l8ycjmmarw6v1nm7jxpgqw2ly0q35idlj0jc0nbxn6";
+       version = "0.2.0.4";
+       sha256 = "0p67lbzcbbm5bkhv0x380bdald6kaqlf968ay2q8qj69izpvk181";
        libraryHaskellDepends = [
          base MonadPrompt mtl random-source transformers
        ];
···
        ];
        description = "Automatic JSON format versioning";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "safe-lazy-io" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "salak_0_3_6" = callPackage
+    ({ mkDerivation, base, bytestring, containers, criterion
+     , data-default, directory, dlist, exceptions, filepath, hashable
+     , heaps, hspec, hspec-discover, megaparsec, mtl, QuickCheck, random
+     , scientific, text, time, unliftio-core, unordered-containers
+     }:
+     mkDerivation {
+       pname = "salak";
+       version = "0.3.6";
+       sha256 = "00qyd09az0ldfidfgcki8z3r9gcpxmss3iyr99as5bky29rlz9n3";
+       libraryHaskellDepends = [
+         base bytestring containers data-default directory dlist exceptions
+         filepath hashable heaps megaparsec mtl scientific text time
+         unliftio-core unordered-containers
+       ];
+       testHaskellDepends = [
+         base hspec mtl QuickCheck random scientific text
+         unordered-containers
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base criterion data-default mtl text time
+       ];
+       description = "Configuration (re)Loader and Parser";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "salak-toml" = callPackage
     ({ mkDerivation, base, criterion, exceptions, hspec, mtl
      , QuickCheck, salak, text, time, tomland, unordered-containers
···
        testToolDepends = [ hspec-discover ];
        description = "Bindings for secp256k1 library from Bitcoin Core";
        license = stdenv.lib.licenses.publicDomain;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {libsecp256k1 = null;};
 
   "secp256k1-legacy" = callPackage
···
        pname = "secp256k1-legacy";
        version = "0.5.6";
        sha256 = "0p7kp7011hfc95rdchkniw3gj5i0pkwgsa5kkhwn6fjzs2clslbz";
+       revision = "1";
+       editedCabalFile = "0fz2nypf6p1qsvcvvfa7ya0pggvkr2jsm306ryy8grncbzy4ydgm";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          base base16-bytestring bytestring cereal entropy mtl QuickCheck
···
        ];
        description = "A tool to send command execution results to Sensu";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "sentence-jp" = callPackage
···
 
   "servant-to-elm" = callPackage
     ({ mkDerivation, aeson, base, bound, elm-syntax, haskell-to-elm
-     , http-types, protolude, servant, servant-multipart, text
+     , http-types, servant, servant-multipart, text
      }:
      mkDerivation {
        pname = "servant-to-elm";
-       version = "0.4.0.0";
-       sha256 = "04i4mcj41c6wzxj9kgy7x8w9f3aaa77rr91c40qbhf1lkf7jmsny";
+       version = "0.4.1.0";
+       sha256 = "0kxkyijkxvpb5jv815i9s6pg7rnq437jj7hrwr0xprxd709mc648";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base bound elm-syntax haskell-to-elm http-types protolude
-         servant servant-multipart text
+         aeson base bound elm-syntax haskell-to-elm http-types servant
+         servant-multipart text
        ];
        testHaskellDepends = [
-         aeson base bound elm-syntax haskell-to-elm http-types protolude
-         servant servant-multipart text
+         aeson base bound elm-syntax haskell-to-elm http-types servant
+         servant-multipart text
        ];
        description = "Automatically generate Elm clients for Servant APIs";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "serverless-haskell";
-       version = "0.10.1";
-       sha256 = "18iqj3c60sx6v1d8lnlv0gcd1xrpvjwqwnshsi2n823dp1j975gp";
-       libraryHaskellDepends = [
-         aeson aeson-casing amazonka-core amazonka-kinesis amazonka-s3 base
-         bytestring case-insensitive http-types iproute lens network
-         network-simple text time unix unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson aeson-casing amazonka-core amazonka-kinesis amazonka-s3 base
-         bytestring case-insensitive hspec hspec-discover http-types iproute
-         lens network network-simple raw-strings-qq text time unix
-         unordered-containers
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Deploying Haskell code onto AWS Lambda using Serverless";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "serverless-haskell_0_10_2" = callPackage
-    ({ mkDerivation, aeson, aeson-casing, amazonka-core
-     , amazonka-kinesis, amazonka-s3, base, bytestring, case-insensitive
-     , hspec, hspec-discover, http-types, iproute, lens, network
-     , network-simple, raw-strings-qq, text, time, unix
-     , unordered-containers
-     }:
-     mkDerivation {
-       pname = "serverless-haskell";
        version = "0.10.2";
        sha256 = "1iy69394dqv38dlh71m8sarcfps9gaaq90zpc4f169vnhpr59wak";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Deploying Haskell code onto AWS Lambda using Serverless";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "serversession" = callPackage
···
      }) {};
 
   "shake-bindist" = callPackage
-    ({ mkDerivation, archive-sig, archive-tar, base, bytestring, bz2
-     , lzlib, shake, zlib, zstd
+    ({ mkDerivation, archive-sig, base, bytestring, bz2, lzlib, shake
+     , zlib, zstd
      }:
      mkDerivation {
        pname = "shake-bindist";
-       version = "0.1.0.0";
-       sha256 = "0f2w7bbnnigfjpfywljl6k2gcz1rq99lfz7cig0076rbjg7aifii";
-       revision = "2";
-       editedCabalFile = "0bk1r9qn41xhhjisvahs0fdsfiv79rb1yk545ry0vw83d0af6kl8";
+       version = "1.0.0.0";
+       sha256 = "0fzq62a8rjh9jc9dc7rfi6ypp0fax7fhlf632a30mrbpk1hqyfz8";
        libraryHaskellDepends = [
-         archive-sig archive-tar base bytestring bz2 lzlib shake zlib zstd
+         archive-sig base bytestring bz2 lzlib shake zlib zstd
        ];
        description = "Rules for binary distributions";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "shake-c" = callPackage
···
        ];
        description = "Lucid support for Skylighting";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "skylighting-modding" = callPackage
···
     ({ mkDerivation, base, QuickCheck, quickcheck-simple }:
      mkDerivation {
        pname = "sql-words";
-       version = "0.1.6.3";
-       sha256 = "11z6g85dzrvkhnz0g6rhv5s2ssqcyyzbi2pp5rwzp30xp0ivsx95";
+       version = "0.1.6.4";
+       sha256 = "1rd2rkhq56zwv3s1jzxq0vjshjnf5818f70w6ayxbmmg87kiwwy0";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck quickcheck-simple ];
        description = "SQL keywords data constructors into OverloadedString";
···
        ];
        description = "Mid-Level SQLite client library";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "sqlite-simple-errors" = callPackage
···
      }:
      mkDerivation {
        pname = "stache";
-       version = "2.1.0";
-       sha256 = "1q34h46px7miy2kx1yzaj785ai70mkchmijpdq2iih1fffir8kvk";
-       revision = "2";
-       editedCabalFile = "0vzby2q8qp6z74ighqalw05b94821cl9w6dbwy4hkgd67pc38nph";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         aeson base bytestring containers deepseq directory filepath
-         megaparsec mtl template-haskell text unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers file-embed hspec hspec-megaparsec
-         megaparsec template-haskell text yaml
-       ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-         aeson base criterion deepseq megaparsec text
-       ];
-       description = "Mustache templates for Haskell";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "stache_2_1_1" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, criterion
-     , deepseq, directory, file-embed, filepath, hspec, hspec-discover
-     , hspec-megaparsec, megaparsec, mtl, template-haskell, text
-     , unordered-containers, vector, yaml
-     }:
-     mkDerivation {
-       pname = "stache";
        version = "2.1.1";
        sha256 = "06pn7pm5vgk9f4bsh3m29cik514nv5w655ip04k7p5jv9xgmn4ld";
        enableSeparateDataOutput = true;
···
        ];
        description = "Mustache templates for Haskell";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "stack" = callPackage
···
        pname = "stack2cabal";
        version = "1.0.5";
        sha256 = "15swq7rv997fh1qka7ga5hc90gc889xzkx61910jz3an6sy5zx0p";
-       revision = "1";
-       editedCabalFile = "15qc686alcfbxjpr7iyi2bxv801cmbkqvncpb6jd0879ll9lznrh";
+       revision = "2";
+       editedCabalFile = "12dkq7shcsyp8yrr2vvzf968w3x11kgxqlam1h0m33zvjksbw6dq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "taffybar";
        version = "3.2.2";
        sha256 = "02b6rmsb89c1h7fr81ljbij30pnl8z4dz6xz367g7a2b9hwq42gz";
+       revision = "1";
+       editedCabalFile = "0284vnzvgpjjh95p67k2b5476npa52hs8g55fvlvlcx487zpc1sc";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "tai";
        version = "0";
        sha256 = "1kp7m9mhawi2fbdsir4kg9z6hbmlw4kmp3kjvlk4qkhvckgl3pxw";
-       revision = "1";
-       editedCabalFile = "0m95bx120pjigxncbdb28y3cv4d6x05vgpjgny86vk0lkslk130y";
+       revision = "3";
+       editedCabalFile = "09wmlfswhs0839iq08br4i4zgjavvwxavcp0i0mldgrj82x9cxfy";
        libraryHaskellDepends = [
          base clock lens mtl parsers time trifecta wreq
        ];
···
        ];
        description = "TAP (Test Anything Protocol) Version 13 formatter for tasty";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "tasty-test-reporter" = callPackage
···
        license = stdenv.lib.licenses.asl20;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) libtensorflow;};
+     }) {libtensorflow = null;};
 
   "tensorflow-core-ops" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, directory, filepath
···
      }:
      mkDerivation {
        pname = "text-replace";
-       version = "0.0.0.4";
-       sha256 = "18hiy0d18wxh8v4zd6vg69fwd8vp9b2yd3ngf04yh9y1bl8wwwhb";
+       version = "0.0.0.6";
+       sha256 = "05hr2185q4rcn1hvrrkqy2sbl8xzk7ij00x61vhvmyk29dbbk2cf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
···
        pname = "text-show-instances";
        version = "3.8.3";
        sha256 = "11v335p3wzf9ijqlkls5mk4m16dfak8fckn4gj7mahs8c7l9lm5d";
-       revision = "1";
-       editedCabalFile = "104r5k4h4sdf69frpc0pr8jijk4v9dalw9c18yib653bwjw0ypl4";
+       revision = "2";
+       editedCabalFile = "001xn2aq5k8hhn5iwhmxv1s3mnxyg630klmmdhbp3lxdb2yq8rha";
        libraryHaskellDepends = [
          base base-compat-batteries bifunctors binary containers directory
          ghc-boot-th haskeline hpc old-locale old-time pretty random
···
      }) {};
 
   "th-instance-reification" = callPackage
-    ({ mkDerivation, base, containers, HTF, list-extras, loch-th
-     , placeholders, template-haskell, th-expand-syns
+    ({ mkDerivation, base, containers, list-extras, QuickCheck
+     , quickcheck-instances, rerebase, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, th-expand-syns
      }:
      mkDerivation {
        pname = "th-instance-reification";
-       version = "0.1.4";
-       sha256 = "0cnq7qxqpc58a59iv8sfqrkhx9wkzpgn9l7r84kh0xa21w16inki";
+       version = "0.1.5";
+       sha256 = "0ssnd45bvz4k0fajc3xlqy7iq92rm0pjn3wwl4brnvaf7l1180q4";
        libraryHaskellDepends = [
-         base containers list-extras loch-th placeholders template-haskell
-         th-expand-syns
+         base containers list-extras template-haskell th-expand-syns
        ];
        testHaskellDepends = [
-         base containers HTF list-extras loch-th placeholders
-         template-haskell th-expand-syns
+         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck template-haskell
        ];
        description = "Fixed versions of instances reification functions";
        license = stdenv.lib.licenses.mit;
···
        broken = true;
      }) {};
 
-  "time_1_9_3" = callPackage
+  "time_1_10" = callPackage
     ({ mkDerivation, base, deepseq, QuickCheck, random, tasty
      , tasty-hunit, tasty-quickcheck, unix
      }:
      mkDerivation {
        pname = "time";
-       version = "1.9.3";
-       sha256 = "03n7lsapydivwj7lv2azb5i31ph8365kzh7zbl3kcgzzmiz9cnsp";
+       version = "1.10";
+       sha256 = "1000fhgcvqagvyhm587zf6y9g2ffj517w0hsvvpbzj1sggyjc93s";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base deepseq QuickCheck random tasty tasty-hunit tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "time-compat";
-       version = "1.9.2.2";
-       sha256 = "05va0rqs759vbridbcl6hksp967j9anjvys8vx72fnfkhlrn2s52";
-       revision = "2";
-       editedCabalFile = "1i94pch4zj713gxcrlb09airbh3hqqs7cscjjfkxk9lixkk6iwnc";
+       version = "1.9.3";
+       sha256 = "126vlfzv3z91vnjlkqarkyhs91hrx4g08gnrvsldqpclczk48smv";
        libraryHaskellDepends = [ base base-orphans deepseq time ];
        testHaskellDepends = [
          base base-compat deepseq HUnit QuickCheck tagged tasty tasty-hunit
···
        testHaskellDepends = [ base directory hspec process ];
        description = "Package to list all tracked and untracked existing files via Git";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "tracker" = callPackage
···
      }:
      mkDerivation {
        pname = "turtle";
-       version = "1.5.16";
-       sha256 = "164cs5gsl6pmfj4yd9p4vj02n1sj5krgd6azd5zfgyw4q7bfc5jn";
-       libraryHaskellDepends = [
-         ansi-wl-pprint async base bytestring clock containers directory
-         exceptions foldl hostname managed optional-args
-         optparse-applicative process semigroups stm streaming-commons
-         system-fileio system-filepath temporary text time transformers unix
-         unix-compat
-       ];
-       testHaskellDepends = [
-         base doctest fail system-filepath temporary
-       ];
-       benchmarkHaskellDepends = [ base criterion text ];
-       description = "Shell programming, Haskell-style";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "turtle_1_5_17" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, async, base, bytestring, clock
-     , containers, criterion, directory, doctest, exceptions, fail
-     , foldl, hostname, managed, optional-args, optparse-applicative
-     , process, semigroups, stm, streaming-commons, system-fileio
-     , system-filepath, temporary, text, time, transformers, unix
-     , unix-compat
-     }:
-     mkDerivation {
-       pname = "turtle";
        version = "1.5.17";
        sha256 = "0chj4issjbkdkj1jbcpi8v104784qnzvkq81a4wcdijk09biphq7";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion text ];
        description = "Shell programming, Haskell-style";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "turtle-options" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "unliftio-pool_0_2_1_1" = callPackage
+    ({ mkDerivation, base, resource-pool, time, transformers
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "unliftio-pool";
+       version = "0.2.1.1";
+       sha256 = "0hxxngldp4zr55qv67gf62a87yxr1f0xfyh4gfzr45q62mscs8xv";
+       libraryHaskellDepends = [
+         base resource-pool time transformers unliftio-core
+       ];
+       description = "Data.Pool generalized to MonadUnliftIO.";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "unliftio-streams" = callPackage
     ({ mkDerivation, base, bytestring, io-streams, text, unliftio-core
      }:
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "validation-selective" = callPackage
+    ({ mkDerivation, base, deepseq, doctest, hedgehog, hspec
+     , hspec-hedgehog, selective, text
+     }:
+     mkDerivation {
+       pname = "validation-selective";
+       version = "0.0.0.0";
+       sha256 = "01awbhfday2j0jcfgqq074yqxxasqddwxhlwigsbjgv94b4c55bd";
+       libraryHaskellDepends = [ base deepseq selective ];
+       testHaskellDepends = [
+         base doctest hedgehog hspec hspec-hedgehog selective text
+       ];
+       description = "Lighweight pure data validation based on Applicative and Selective functors";
+       license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "validations" = callPackage
     ({ mkDerivation, base, containers, digestive-functors, HUnit, mtl
      , QuickCheck, test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "wai-enforce-https";
-       version = "0.0.2";
-       sha256 = "0p3j438knirr32j6dhqscws93h3ygk6lvw97r489h8i1dip9rqll";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bytestring case-insensitive http-types network text wai
-       ];
-       testHaskellDepends = [
-         base bytestring case-insensitive hspec http-types wai wai-extra
-       ];
-       description = "Enforce HTTPS in Wai server app safely";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "wai-enforce-https_0_0_2_1" = callPackage
-     , Only, should-not-typecheck, single-tuple, text
-     , http-types, network, text, wai, wai-extra
-     }:
-     mkDerivation {
-       pname = "wai-enforce-https";
        version = "0.0.2.1";
        sha256 = "1mbhk50j1a47ydg5kd6bj3nbzqfq1abm1d1vcxc3smw4fgf39g5x";
        isLibrary = true;
···
        ];
        description = "Enforce HTTPS in Wai server app safely";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "wai-eventsource" = callPackage
···
        broken = true;
      }) {};
 
+  "wai-middleware-clacks" = callPackage
+    ({ mkDerivation, base, base-compat-batteries, bytestring
+     , case-insensitive, http-types, tasty, tasty-wai, text, wai
+     }:
+     mkDerivation {
+       pname = "wai-middleware-clacks";
+       version = "0.1.0.1";
+       sha256 = "1mx3qmyiywib8wcrccxd7wjlx4jv9wlc5w8lykivgh8q66pbcihf";
+       libraryHaskellDepends = [
+         base base-compat-batteries bytestring case-insensitive http-types
+         text wai
+       ];
+       testHaskellDepends = [
+         base base-compat-batteries http-types tasty tasty-wai wai
+       ];
+       description = "GNU Terry Pratchett - Add the X-Clacks-Overhead Header to Wai Responses";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "wai-middleware-consul" = callPackage
     ({ mkDerivation, async, base, base-prelude, bytestring, conduit
      , conduit-extra, consul-haskell, enclosed-exceptions, http-client
···
        pname = "wai-middleware-static";
        version = "0.8.3";
        sha256 = "0l6az106r970v3jwx3z7fg7x8ja8x5hla0m5lwg7sjfs9vdh0bnl";
+       revision = "1";
+       editedCabalFile = "0jinswa97ll70xxj6hm4mxw7i1cfnm8jn87aczzccn9xscdpll4c";
        libraryHaskellDepends = [
          base bytestring containers cryptonite directory expiring-cache-map
          filepath http-types memory mime-types mtl old-locale semigroups
···
 
   "warp-grpc" = callPackage
      , Only, should-not-typecheck, single-tuple, text
-     , http-types, http2, http2-grpc-types, wai, warp, warp-tls
+     , http-types, http2, http2-grpc-types, unliftio-core, wai, warp
+     , warp-tls
      }:
      mkDerivation {
        pname = "warp-grpc";
-       version = "0.3.0.0";
-       sha256 = "15zpb9liai56i9765sf05kww7zykd68kd38vc0s0rhx9jgqk2clj";
+       version = "0.4.0.0";
+       sha256 = "1isi0xd6vvavvr4m3gfiqj2cmmpa3jn9py61m0ksrarxwmsw8s1g";
        libraryHaskellDepends = [
          async base binary bytestring case-insensitive http-types http2
-         http2-grpc-types wai warp warp-tls
+         http2-grpc-types unliftio-core wai warp warp-tls
        ];
        description = "A minimal gRPC server on top of Warp";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "weeder" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, cmdargs, deepseq
-     , directory, extra, filepath, foundation, hashable, process, text
-     , unordered-containers, vector, yaml
+    ({ mkDerivation, algebraic-graphs, base, bytestring, containers
+     , dhall, directory, filepath, generic-lens, ghc, lens, mtl
+     , optparse-applicative, regex-tdfa, transformers
      }:
      mkDerivation {
        pname = "weeder";
-       version = "1.0.8";
-       sha256 = "1ylwq1087x6ppn5y5krvl6q6fxcln58y8fwbah3ygp0cpgm4w816";
+       version = "2.0.1";
+       sha256 = "1x5hgyp3zcwz63wcwh8bqalckcb7baakj39zwymifirxvhkws1xz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base bytestring cmdargs deepseq directory extra filepath
-         foundation hashable process text unordered-containers vector yaml
+         algebraic-graphs base bytestring containers dhall directory
+         filepath generic-lens ghc lens mtl optparse-applicative regex-tdfa
+         transformers
        ];
-       executableHaskellDepends = [ base ];
+       executableHaskellDepends = [
+         base bytestring containers directory filepath ghc
+         optparse-applicative transformers
+       ];
        description = "Detect dead code";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "wordlist";
-       version = "0.1.0.2";
-       sha256 = "1p3pzacg4s0hx4gq2slm1bgkvr8fh3q1iqlpidbc3pc9whclr173";
+       version = "0.1.0.4";
+       sha256 = "0v2xnm4iqk8wh3l05vkmfblwk49q54awp2qr1cwszgxfzaz4n9zb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base optparse-applicative text ];
···
      }:
      mkDerivation {
        pname = "yaml";
-       version = "0.11.2.0";
-       sha256 = "035sqc2bnya3ghv5i0qk9jdg9q6jvqzgnc5gkg9mgf4drjrd5wni";
-       configureFlags = [ "-fsystem-libyaml" ];
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson attoparsec base bytestring conduit containers directory
-         filepath libyaml mtl resourcet scientific template-haskell text
-         transformers unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson attoparsec base base-compat bytestring conduit containers
-         directory filepath hspec HUnit libyaml mockery mtl raw-strings-qq
-         resourcet scientific template-haskell temporary text transformers
-         unordered-containers vector
-       ];
-       description = "Support for parsing and rendering YAML documents";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "yaml_0_11_3_0" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
-     , conduit, containers, directory, filepath, hspec, HUnit, libyaml
-     , mockery, mtl, raw-strings-qq, resourcet, scientific
-     , template-haskell, temporary, text, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "yaml";
        version = "0.11.3.0";
        sha256 = "01lafh83rp0v49f052vyv4gcbdgzcf42cmg0iqlykk6c586ksvh4";
        configureFlags = [ "-fsystem-libyaml" ];
···
        ];
        description = "Support for parsing and rendering YAML documents";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yaml-combinators" = callPackage
···
        pname = "yampa-canvas";
        version = "0.2.3";
        sha256 = "0a1pq1psmc4490isr19z4prnqq1w3374vkfmzpw9s20s2p6k5y7r";
-       revision = "3";
-       editedCabalFile = "02zzv9xlmvja8jpgnk1r7wfrh33593qbmhbwrcnw0bmjvbk28ps1";
+       revision = "4";
+       editedCabalFile = "0yx1g19shmrhapmyqzksh861zyyrlwvv158ls5n9imlxr21zssf3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base blank-canvas stm time Yampa ];
···
      }:
      mkDerivation {
        pname = "yeamer";
-       version = "0.1.0.3";
-       sha256 = "02v33ya0nc0qvsnc5dz33kargyprzxjhbrcdfi439psxh43rw9fp";
+       version = "0.1.0.5";
+       sha256 = "0c8yrh43h9qhhdiz0dnrh00frfz0cymzzz9k723jnp03b8994srq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "yesod-auth-fb";
-       version = "1.9.1";
-       sha256 = "1368hxic51vnilwp6dygc98yfclqi0vn1vwkxpvdd9vzy73kdj0i";
+       version = "1.10.1";
+       sha256 = "01ckr3zs9bqwwskah2fd7rkpirifyl16v1xk062qx87zcwkf408r";
        libraryHaskellDepends = [
          aeson base bytestring conduit fb http-conduit resourcet shakespeare
          text time transformers unliftio wai yesod-auth yesod-core yesod-fb
···
      }:
      mkDerivation {
        pname = "yesod-fb";
-       version = "0.6.0";
-       sha256 = "0anhnbwc9j11lm2sh8wi15p160vb9g0ng8lqc6g8am61jsxxw40x";
+       version = "0.6.1";
+       sha256 = "1nyi5jp85ysabljkds6h4w8ndrb12ac76awsih52amf60k4n7afl";
        libraryHaskellDepends = [
          aeson base bytestring conduit fb http-client-tls http-conduit
          memory text wai yesod-core
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "zip_1_4_0" = callPackage
+  "zip_1_4_1" = callPackage
     ({ mkDerivation, base, bytestring, bzlib-conduit, case-insensitive
      , cereal, conduit, conduit-extra, containers, digest, directory
      , dlist, exceptions, filepath, hspec, monad-control, mtl
···
      }:
      mkDerivation {
        pname = "zip";
-       version = "1.4.0";
-       sha256 = "07g17n6fr86c6c5yhs8ml53mk0g032060vja620bp32irfm00m2r";
+       version = "1.4.1";
+       sha256 = "0jnvqss17zjfs91flsammlx4flw527iddlav37jzqihi6j65aqp2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [

pkgs/top-level/all-packages.nix

···
 
   icecast = callPackage ../servers/icecast { };
 
+  icepeak = haskell.lib.justStaticExecutables haskellPackages.icepeak;
+
   iceshelf = callPackage ../tools/backup/iceshelf { };
 
   darkice = callPackage ../tools/audio/darkice { };