Merge pull request #65852 from NixOS/haskell-updates

LTS Haskell 13.30

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

···
       name = "git-annex-${super.git-annex.version}-src";
       url = "git://git-annex.branchable.com/";
       rev = "refs/tags/" + super.git-annex.version;
-      sha256 = "11d4qyhmc774h2xyrpyn9rxx99x3vjs0fcxsg49gj5ayzmykafap";
+      sha256 = "1pz12l0awshdq5xyac5awjd902sy9l65z6ihya4pzapik4gqfdcd";
     };
   }).override {
     dbus = if pkgs.stdenv.isLinux then self.dbus else null;
···
     '';
   });
 
-  hsdev_0_3_3_1 = super.hsdev_0_3_3_1.overrideScope (self: super: {
+  hsdev_0_3_3_2 = super.hsdev_0_3_3_2.overrideScope (self: super: {
     haskell-names = self.haskell-names_0_9_6;
     network = self.network_3_0_1_1;
   });
···
     concurrent-output = self.concurrent-output_1_10_10; # needed for new ansi-terminal version
     hi-file-parser = dontCheck (unmarkBroken super.hi-file-parser);  # Avoid depending on newer hspec versions.
     http-download = dontCheck (unmarkBroken super.http-download);
-    pantry-tmp = dontCheck (unmarkBroken super.pantry-tmp);
-    rio = self.rio_0_1_10_0;
+    pantry = dontCheck (unmarkBroken super.pantry);
+    rio = self.rio_0_1_11_0;
     rio-prettyprint = unmarkBroken super.rio-prettyprint;
+    unliftio = self.unliftio_0_2_12;
   }));
 
   # musl fixes
···
   cmark-gfm = self.cmark-gfm_0_2_0;
   pandoc = dontCheck (doDistribute super.pandoc_2_7_3);  # test suite failure: https://github.com/jgm/pandoc/issues/5582
   pandoc-citeproc = doDistribute super.pandoc-citeproc_0_16_2;
-  skylighting = self.skylighting_0_8_1_1;
-  skylighting-core = self.skylighting-core_0_8_1_1;
+  skylighting = self.skylighting_0_8_2;
+  skylighting-core = self.skylighting-core_0_8_2;
 
   # Current versions of tasty-hedgehog need hedgehog 1.x, which
   # we don't have in LTS-13.x.
···
   temporary-resourcet = doJailbreak super.temporary-resourcet;
 
   # Requires dhall >= 1.23.0
-  ats-pkg = super.ats-pkg.override { dhall = self.dhall_1_24_0; };
-  dhall-to-cabal = super.dhall-to-cabal.override { dhall = self.dhall_1_24_0; };
+  ats-pkg = super.ats-pkg.override { dhall = self.dhall_1_25_0; };
+  dhall-to-cabal = super.dhall-to-cabal.override { dhall = self.dhall_1_25_0; };
 
   # Test suite doesn't work with current QuickCheck
   # https://github.com/pruvisto/heap/issues/11
···
   constraints-deriving = dontCheck super.constraints-deriving;
 
   # The old LTS-13.x version does not compile.
-  ip = self.ip_1_5_0;
+  ip = self.ip_1_5_1;
 
   # Needs deque >= 0.3, but latest version on stackage is 2.7
   butcher = super.butcher.override { deque = self.deque_0_4_2_3; };

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

···
   - ghcjs-base-0
 
 default-package-overrides:
-  # LTS Haskell 13.27
+  # LTS Haskell 13.30
   - abstract-deque ==0.3
   - abstract-deque-tests ==0.3
   - abstract-par ==0.3.3
···
   - bzlib ==0.5.0.5
   - bzlib-conduit ==0.3.0.1
   - c2hs ==0.28.6
+  - Cabal ==2.4.1.0
   - cabal2spec ==2.2.2.1
   - cabal-doctest ==1.0.6
   - cabal-rpm ==0.12.6
···
   - hashids ==1.0.2.4
   - hashmap ==1.3.3
   - hashtables ==1.2.3.3
+  - haskeline ==0.7.5.0
   - haskell-gi ==0.21.5
   - haskell-gi-base ==0.21.5
   - haskell-gi-overloading ==1.0
···
   - mono-traversable ==1.0.11.0
   - mono-traversable-instances ==0.1.0.0
   - mountpoints ==1.0.2
+  - mtl ==2.2.2
   - mtl-compat ==0.2.2
   - mtl-prelude ==2.0.3.1
   - multiarg ==0.30.0.10
···
   - parallel-io ==0.3.3
   - paripari ==0.6.0.0
   - parseargs ==0.2.0.9
+  - parsec ==3.1.13.0
   - parsec-class ==1.0.0.0
   - parsec-numbers ==0.1.0
   - parsec-numeric ==0.1.0.0
···
   - statistics ==0.15.0.0
   - stb-image-redux ==0.2.1.2
   - step-function ==0.2
+  - stm ==2.5.0.0
   - stm-chans ==3.0.0.4
   - stm-conduit ==4.0.1
   - stm-delay ==0.1.1.1
···
   - testing-feat ==1.1.0.0
   - testing-type-modifiers ==0.1.0.1
   - texmath ==0.11.2.2
+  - text ==1.2.3.1
   - text-binary ==0.2.1.1
   - text-builder ==0.6.5.1
   - text-conversions ==0.3.0
···
   - xdg-basedir ==0.2.2
   - xeno ==0.3.5.1
   - xenstore ==0.1.1
+  - xhtml ==3000.2.2.1
   - xls ==0.1.2
   - xlsx ==0.7.2
   - xlsx-tabular ==0.2.2.1
···
     - funcmp
     - git-annex
     - hackage-db
+    - haskell-ci
     - hledger
     - hledger-interest
     - hledger-ui
···
   - apelsin
   - api-builder
   - api-tools
+  - api-yoti
   - apiary
   - apiary-authenticate
   - apiary-clientsession
···
   - atomic-primops-vector
   - atomo
   - ats-format
+  - ats-pkg
   - ats-setup
   - ats-storable
   - attic-schedule
···
   - azurify
   - b9
   - babylon
+  - backblaze-b2-hs
   - backdropper
+  - backstop
   - backtracking-exceptions
   - backward-state
   - bag
···
   - bdcs-api
   - beam
   - beam-newtype-field
+  - beam-postgres
   - beam-th
   - beamable
   - beautifHOL
···
   - blunt
   - BNFC-meta
   - bno055-haskell
+  - board-games
   - bogre-banana
   - bolt
   - boltzmann-brain
···
   - boolexpr
   - boombox
   - boomslang
+  - boots
   - borel
   - boring-window-switcher
   - bot
   - bounded-array
   - bowntz
+  - box
   - braid
   - brain-bleep
   - Bravo
···
   - call-haskell-from-anything
   - camfort
   - campfire
+  - canon
   - canonical-filepath
   - canonical-json
   - canteven-http
···
   - checked
   - Checked
   - checkmate
+  - chell
+  - chell-hunit
+  - chell-quickcheck
   - chessIO
   - chevalier-common
   - chiasma
···
   - crf-chain2-generic
   - crf-chain2-tiers
   - critbit
+  - criterion-compare
   - criterion-plus
   - criterion-to-html
   - criu-rpc
···
   - data-type
   - data-util
   - data-variant
+  - database-id-groundhog
   - database-study
   - datadog
   - datadog-tracing
···
   - dgim
   - dgs
   - dhall-check
+  - dhall-lsp-server
   - dhall-nix
+  - dhall-to-cabal
   - dhcp-lease-parser
+  - dhrun
   - dia-base
   - dia-functions
   - diagrams-boolean
···
   - dirtree
   - discogs-haskell
   - discord-gateway
-  - discord-haskell
   - discord-hs
   - discord-rest
   - discord-types
···
   - effect-handlers
   - effect-stack
   - effin
+  - egison
   - egison-quote
   - egison-tutorial
   - ehaskell
···
   - entangle
   - EntrezHTTP
   - entwine
+  - enum-text-rio
   - EnumContainers
   - enumerate
   - enumerate-function
···
   - FM-SBLEX
   - fmark
   - FModExRaw
+  - fmt-for-rio
   - fn-extra
   - foldl-incremental
   - foldl-statistics
···
   - gact
   - game-probability
   - gameclock
+  - gamgee
   - Gamgine
   - gamma
   - Ganymede
···
   - ghcjs-promise
   - ghcjs-xhr
   - ghclive
+  - ghcprofview
   - ght
   - gi-cairo-again
   - gi-dbusmenu
···
   - gi-gstpbutils
   - gi-gsttag
   - gi-gstvideo
+  - gi-gtk
+  - gi-gtk-declarative
+  - gi-gtk-declarative-app-simple
+  - gi-gtk-hs
   - gi-gtkosxapplication
+  - gi-gtksource
   - gi-handy
   - gi-notify
   - gi-ostree
···
   - gi-poppler
   - gi-secret
   - gi-soup
+  - gi-vte
   - gi-wnck
   - gi-xlib
   - giak
···
   - gtfs
   - gtk-serialized-event
   - gtk-sni-tray
+  - gtk-strut
   - gtk-toy
   - gtk2hs-hello
   - gtk2hs-rpn
···
   - hArduino
   - hardware-edsl
   - HaRe
+  - harg
   - hark
   - harmony
   - HarmTrace
···
   - hjson-query
   - hjsonpointer
   - hjsonschema
+  - hjugement-cli
   - HJVM
   - hkgr
   - hlatex
···
   - identifiers
   - idiii
   - idna2008
+  - idris
   - IDynamic
   - ieee-utils
+  - iexcloud
   - ifcxt
   - IFS
   - ig
···
   - ks-test
   - KSP
   - ktx
+  - kubernetes-client
+  - kubernetes-client-core
   - kure
   - kure-your-boilerplate
   - KyotoCabinet
···
   - lambda-calculator
   - lambda-canvas
   - lambda-devs
+  - lambda-options
   - lambda-toolbox
   - lambda2js
   - lambdaBase
···
   - marxup
   - masakazu-bot
   - MASMGen
+  - massiv-test
   - master-plan
   - matchers
   - math-grads
···
   - mellon-gpio
   - mellon-web
   - melody
+  - membrain
   - memcache-conduit
   - memcache-haskell
   - memcached-binary
···
   - network-netpacket
   - network-protocol-xmpp
   - network-rpca
+  - network-run
   - network-server
   - network-service
   - network-simple
···
   - optional
   - options-time
   - optparse-applicative-simple
+  - optparse-enum
   - orc
   - orchestrate
   - OrchestrateDB
···
   - pang-a-lambda
   - pangraph
   - panpipe
+  - pantry
   - pantry-tmp
   - papa-export
   - papa-implement
···
   - pasta
   - pastis
   - pasty
+  - patat
   - patches-vector
   - Pathfinder
   - pathfindingcore
···
   - postgresql-named
   - postgresql-query
   - postgresql-simple-bind
+  - postgresql-simple-named
   - postgresql-simple-queue
   - postgresql-simple-sop
   - postgresql-simple-typed
···
   - Referees
   - refh
   - reflection-extras
+  - reflex
   - reflex-animation
   - reflex-backend-wai
+  - reflex-basic-host
   - reflex-dom-svg
   - reflex-gloss
   - reflex-gloss-scene
···
   - rfc1413-server
   - rhythm-game-tutorial
   - RichConditional
+  - ridley
+  - ridley-extras
   - riemann
   - riff
   - ring-buffer
···
   - scotty-binding-play
   - scotty-blaze
   - scotty-fay
+  - scotty-form
   - scotty-format
   - scotty-hastache
   - scotty-resource
···
   - statsd-client
   - statsdi
   - stb-image-redux
+  - stc-lang
   - stdata
   - stdf
   - stdio
···
   - StrappedTemplates
   - stratum-tool
   - stratux
+  - stratux-demo
   - stratux-http
   - stratux-types
   - stratux-websockets
···
   - symantic-cli
   - symantic-http-test
   - symantic-lib
+  - symantic-xml
   - symengine
   - symengine-hs
   - sync
···
   - terminal-punch
   - terminal-text
   - termination-combinators
+  - termonad
   - termplot
   - terntup
   - terrahs
···
   - trace-function-call
   - traced
   - tracetree
+  - tracing
   - tracker
   - traction
   - tracy
···
   - translatable-intset
   - translate
   - translate-cli
+  - trasa-extra
+  - trasa-th
   - travis
   - travis-meta-yaml
   - trawl
···
   - unsequential
   - unused
   - uom-plugin
+  - up
   - update-nix-fetchgit
   - Updater
   - uploadcare
···
   - urldecode
   - UrlDisp
   - urldisp-happstack
+  - urlpath
   - URLT
   - urn
   - urn-random
···
   - verilog
   - versioning
   - versioning-servant
+  - vflow-types
   - vfr-waypoints
   - vgrep
   - vhd
···
   - writer-cps-lens
   - writer-cps-monads-tf
   - writer-cps-morph
+  - ws
   - wsdl
   - wsedit
   - wss-client
···
   - wxSimpleCanvas
   - wxturtle
   - wyvern
+  - X
   - x-dsp
   - X11-extras
   - X11-rm
···
   - yate
   - yavie
   - yaya
+  - yaya-hedgehog
   - yaya-unsafe
   - ycextra
   - yeller

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

···
   snap-server = dontCheck super.snap-server;
 
   # Tests require internet
-  dhall_1_24_0 = dontCheck super.dhall_1_24_0;
+  dhall_1_25_0 = dontCheck super.dhall_1_25_0;
 
 }

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

···
      }:
      mkDerivation {
        pname = "AbortT-transformers";
-       version = "1.0.1.2";
-       sha256 = "1skqp7zmh7vzrfhfnc6mn125xmqz2p0c8pmaccxynga9623dmsb2";
+       version = "1.0.1.3";
+       sha256 = "14bv2bmd6fi1kf0id3ah7gfabbqzbpahws6zy11ji6h3j29pwk8y";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
···
        pname = "Cabal";
        version = "2.4.1.0";
        sha256 = "151mrrd9sskghvlwmj32da5gafwqj6sv9xz9fmp84b7vm4nr0skk";
-       revision = "1";
-       editedCabalFile = "1dvs2i0kfk8rji9wbrv7y0iydbif9jzg4c7rmaa6lxg8hp7mij2n";
+       revision = "2";
+       editedCabalFile = "04kg5xh8yabmp1ymk32gw2r66l76338rsglq8i4j2913bhq23vwa";
        setupHaskellDepends = [ mtl parsec ];
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
···
      }:
      mkDerivation {
        pname = "ChasingBottoms";
-       version = "1.3.1.5";
-       sha256 = "0hfk2cb9da5fvr96x8lzij93yl3rvax2id9a8gihd5j5aq4kxx30";
+       version = "1.3.1.6";
+       sha256 = "17lw2mdzrn2f4w0byfdkyd7h7pcnjzv3n3giapcjg6bza5xjqfbd";
        libraryHaskellDepends = [
          base containers mtl QuickCheck random syb
        ];
···
     ({ mkDerivation, base, containers }:
      mkDerivation {
        pname = "LParse";
-       version = "0.3.0.0";
-       sha256 = "0nl76ycq608p2wm61pqn64wmq5aqmnwc9p8k4mvx8zwqw06jqlmm";
+       version = "0.3.1.0";
+       sha256 = "1fw5s0688d5x2i2qarac2r96pj13b2fhla0212fzwlsgpbmg7g8z";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base ];
        description = "A continuation-based parser library";
···
      }) {};
 
   "Monadoro" = callPackage
-    ({ mkDerivation, ansi-terminal, base, process, time }:
+    ({ mkDerivation, ansi-terminal, base, doctest, time }:
      mkDerivation {
        pname = "Monadoro";
-       version = "0.1.2.0";
-       sha256 = "1bqaiarr5gv42xl8fww67iryyh1mscwdkgcahdc988y19ag8a4j9";
+       version = "0.2.1.1";
+       sha256 = "0f7swjf5lr7w7gld46l74plc2x79v6dbq5zmsglpk1x8k7vpfj79";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ ansi-terminal base process time ];
-       executableHaskellDepends = [ ansi-terminal base process time ];
-       testHaskellDepends = [ ansi-terminal base process time ];
-       description = "A minimalistic CLI Pomodoro timer, based on a library of the same purpose";
+       libraryHaskellDepends = [ ansi-terminal base time ];
+       executableHaskellDepends = [ ansi-terminal base time ];
+       testHaskellDepends = [ ansi-terminal base doctest time ];
+       description = "A minimalistic CLI Pomodoro timer";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "Persistence";
-       version = "1.1.4.2";
-       sha256 = "0lvzzcmsmpmsj63ysf3ad6a2v14cf61daz767fxkcf7b7cl50cjp";
+       version = "2.0";
+       sha256 = "0iwkvplldy6sznp33n5w5ink312cg6shh3qg98canz6j6hrspa8y";
+       revision = "1";
+       editedCabalFile = "063rizxqn44pzblj2nxyk3ia2zymryrqq55n081g21aih38n8xlr";
        libraryHaskellDepends = [
          base containers maximal-cliques parallel vector
        ];
-       description = "Quickly detect clusters and holes in data";
+       testHaskellDepends = [
+         base containers maximal-cliques parallel vector
+       ];
+       description = "A versatile library for topological data analysis";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
···
      }) {};
 
   "ShellCheck" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
-     , directory, mtl, parsec, process, QuickCheck, regex-tdfa
+    ({ mkDerivation, aeson, array, base, bytestring, Cabal, containers
+     , deepseq, Diff, directory, filepath, mtl, parsec, process
+     , QuickCheck, regex-tdfa
      }:
      mkDerivation {
        pname = "ShellCheck";
-       version = "0.6.0";
-       sha256 = "1xkxrn1j5qvh2pxm0cnjpqqqsvwr7xy8pk31cwbh8r879nrrzrzn";
+       version = "0.7.0";
+       sha256 = "1vx895cp5k5h0680xfwj74lk97m9y627n965x6srds0gfnbkzy9s";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal process ];
        libraryHaskellDepends = [
-         aeson base bytestring containers directory mtl parsec process
-         QuickCheck regex-tdfa
+         aeson array base bytestring containers deepseq Diff directory
+         filepath mtl parsec process QuickCheck regex-tdfa
        ];
        executableHaskellDepends = [
-         aeson base bytestring containers directory mtl parsec QuickCheck
-         regex-tdfa
+         aeson array base bytestring containers deepseq Diff directory
+         filepath mtl parsec QuickCheck regex-tdfa
        ];
        testHaskellDepends = [
-         aeson base bytestring containers directory mtl parsec QuickCheck
-         regex-tdfa
+         aeson array base bytestring containers deepseq Diff directory
+         filepath mtl parsec QuickCheck regex-tdfa
        ];
        description = "Shell script analysis tool";
        license = stdenv.lib.licenses.gpl3;
···
      }:
      mkDerivation {
        pname = "TeX-my-math";
-       version = "0.201.1.1";
-       sha256 = "064ram3i1a59ypd8i3wnp7x9vbkc8zawby52676y4pfkqvddnhnm";
+       version = "0.201.2.0";
+       sha256 = "1dg06lqh2x9smq6hbcn2gyh2qll9z7v4gbd1ipvf2isdwxc201vk";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
          base decimal-literals dumb-cas hashable haskell-src-meta HaTeX
          template-haskell text unordered-containers vector-space void
+       ];
+       executableHaskellDepends = [
+         base directory filepath HaTeX process text
        ];
        testHaskellDepends = [
          base directory dumb-cas filepath haskell-src-meta HaTeX process
···
        broken = true;
      }) {};
 
+  "X" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, text, text-short }:
+     mkDerivation {
+       pname = "X";
+       version = "0.2.0.0";
+       sha256 = "1p03ah2qi694kcbwb7gk2cypj6p42c6ajn51wpak96p9vmpp5a4r";
+       libraryHaskellDepends = [
+         base bytestring deepseq text text-short
+       ];
+       description = "A light-weight XML library";
+       license = "BSD-3-Clause AND GPL-3.0-or-later";
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "X11" = callPackage
     ({ mkDerivation, base, data-default, libX11, libXext, libXinerama
      , libXrandr, libXrender, libXScrnSaver
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "alist";
-       version = "0.1.1.7";
-       sha256 = "1kklhgksg0lvl4v80y82c5zsfwrr7nbdb8sl64529589sfrsrpsw";
+       version = "0.1.2.7";
+       sha256 = "0ydq2sxyfgij0rf54i3ajj4hdqjawhcdsgi822yrkq86xjvsxc4w";
        libraryHaskellDepends = [ base ];
        description = "lists with O(1) append";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "antiope-athena_7_1_2" = callPackage
+  "antiope-athena_7_2_2" = callPackage
     ({ mkDerivation, amazonka, amazonka-athena, amazonka-core, base
      , lens, resourcet, text, unliftio-core
      }:
      mkDerivation {
        pname = "antiope-athena";
-       version = "7.1.2";
-       sha256 = "19xh9cm859r3p5n0plpwddp4zkgr3sg74xx8m4zv160xi3dggjia";
+       version = "7.2.2";
+       sha256 = "1a5mp3s22qv41p9cgiyz6gc96kwz9f9wwx8v4dr1jjgslmlik4m1";
        libraryHaskellDepends = [
          amazonka amazonka-athena amazonka-core base lens resourcet text
          unliftio-core
···
     ({ mkDerivation, aeson, antiope-s3, avro, base, bytestring, text }:
      mkDerivation {
        pname = "antiope-contract";
-       version = "7.1.2";
-       sha256 = "0k6zn6nhl5b92qjbaxlm1fk21k4anhlm1p86ggydnw8alh9r2lwc";
+       version = "7.2.2";
+       sha256 = "188p6b4mzj513ylkjlf9z3cra6qdv6x0ar4fc1hjs1waggng0b9d";
        libraryHaskellDepends = [
          aeson antiope-s3 avro base bytestring text
        ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "antiope-core_7_1_2" = callPackage
+  "antiope-core_7_2_2" = callPackage
     ({ mkDerivation, aeson, aeson-lens, amazonka, amazonka-core, base
      , bytestring, exceptions, generic-lens, hedgehog, hspec
      , http-client, http-types, hw-hspec-hedgehog, lens, mtl, resourcet
···
      }:
      mkDerivation {
        pname = "antiope-core";
-       version = "7.1.2";
-       sha256 = "0i3gwc07hkl50abkk80jnjkp6iixn6hr6q2h1kj206d6cigjx0cn";
+       version = "7.2.2";
+       sha256 = "0j27bd5f9zkx0qhsl9zam7rzvprcb5075rm174gr77gmf4lqraaa";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core base bytestring exceptions
          generic-lens http-client http-types lens mtl resourcet text
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "antiope-dynamodb_7_1_2" = callPackage
-    ({ mkDerivation, amazonka, amazonka-core, amazonka-dynamodb
+  "antiope-dynamodb_7_2_2" = callPackage
+    ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-dynamodb
      , antiope-core, base, generic-lens, lens, text, unliftio-core
      , unordered-containers
      }:
      mkDerivation {
        pname = "antiope-dynamodb";
-       version = "7.1.2";
-       sha256 = "0g74fg6fclmrfjkhgqyhq95l967bhjah6rk0davrbd3dfandr612";
+       version = "7.2.2";
+       sha256 = "19a41njxa09sf1qlc9zmy65nmwp02lcn0q0dk5gwqkpmjjf5ah3s";
        libraryHaskellDepends = [
-         amazonka amazonka-core amazonka-dynamodb antiope-core base
+         aeson amazonka amazonka-core amazonka-dynamodb antiope-core base
          generic-lens lens text unliftio-core unordered-containers
        ];
        testHaskellDepends = [
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "antiope-messages_7_1_2" = callPackage
+  "antiope-messages_7_2_2" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-core, base, bytestring
      , generic-lens, hedgehog, hspec, hw-hspec-hedgehog, lens
      , lens-aeson, monad-loops, network-uri, scientific, text
···
      }:
      mkDerivation {
        pname = "antiope-messages";
-       version = "7.1.2";
-       sha256 = "0y2dwf0sbay4dm9ns11k2qpjqmgnvxswmd508bwf52305avi97vc";
+       version = "7.2.2";
+       sha256 = "0vdp8kkqv4g3lkjvwhg4yyb8rjwphjp4gjmx0b6910jwizhslqwf";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core base bytestring generic-lens lens
          lens-aeson monad-loops network-uri text unliftio-core
···
      }:
      mkDerivation {
        pname = "antiope-optparse-applicative";
-       version = "7.1.2";
-       sha256 = "0cp9yizvibhi7bwm22z62gx8hv3cm1vbpbv70a0ws4k2i2cq8yrr";
+       version = "7.2.2";
+       sha256 = "006jr3kdyvfzyabxr4zc4kf9sm8pkaca572whdxwpnfpz0m54k0j";
        libraryHaskellDepends = [
          amazonka amazonka-core amazonka-s3 base optparse-applicative text
        ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "antiope-s3_7_1_2" = callPackage
+  "antiope-s3_7_2_2" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3
      , antiope-core, antiope-messages, attoparsec, base, bytestring
      , conduit, conduit-extra, exceptions, generic-lens, hedgehog, hspec
···
      }:
      mkDerivation {
        pname = "antiope-s3";
-       version = "7.1.2";
-       sha256 = "1z85kn6675r54f1hnfn6g0yhg7cjfka32h913qnljd7qmb6ikhhs";
+       version = "7.2.2";
+       sha256 = "14lmkkr86n8h7iqkjvc5sxmccxi3fv97kgljb8m8fl35fxcwd1j8";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-s3 antiope-core
          antiope-messages attoparsec base bytestring conduit conduit-extra
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "antiope-sns_7_1_2" = callPackage
+  "antiope-sns_7_2_2" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-sns, base
      , bytestring, generic-lens, hedgehog, hspec, hw-hspec-hedgehog
      , lens, text, time, unliftio-core
      }:
      mkDerivation {
        pname = "antiope-sns";
-       version = "7.1.2";
-       sha256 = "14mq13q6gvg8r3dm329xzbbxlxxx0p5r5gyyqglpqfmdi5dy9948";
+       version = "7.2.2";
+       sha256 = "10wbf6pmws8gway4i7z55z7xi2az5xzb65yj0q1qc86vxbchnxkk";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-sns base bytestring
          generic-lens lens text time unliftio-core
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "antiope-sqs_7_1_2" = callPackage
+  "antiope-sqs_7_2_2" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-sqs, base
      , bytestring, conduit, generic-lens, hedgehog, hspec
      , hw-hspec-hedgehog, lens, lens-aeson, monad-loops, mtl
···
      }:
      mkDerivation {
        pname = "antiope-sqs";
-       version = "7.1.2";
-       sha256 = "0gpg340nwnni7ybzcq82i7p3j61gw1120209s9ziyqfrlbs7r976";
+       version = "7.2.2";
+       sha256 = "0qjnwrc23zav84s4ffqi2g97yrfpkxmzm981ik6h5fsi7f6wzj0n";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-sqs base bytestring conduit
          generic-lens lens lens-aeson monad-loops mtl network-uri split text
···
        description = "Please see the README on Github at <https://github.com/arbor/antiope#readme>";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "antiope-swf" = callPackage
+    ({ mkDerivation, amazonka-swf, base, hedgehog, hspec
+     , hw-hspec-hedgehog, lens, text
+     }:
+     mkDerivation {
+       pname = "antiope-swf";
+       version = "7.2.2";
+       sha256 = "1shw4sw0nfrkdcjjin3nq63igfalywz03w171v5knn2kx6xwf4yy";
+       libraryHaskellDepends = [ amazonka-swf base lens text ];
+       testHaskellDepends = [ base hedgehog hspec hw-hspec-hedgehog ];
+       description = "Please see the README on Github at <https://github.com/arbor/antiope#readme>";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "antiprimes" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "apecs_0_8_1" = callPackage
+    ({ mkDerivation, array, base, containers, criterion, linear, mtl
+     , QuickCheck, template-haskell, vector
+     }:
+     mkDerivation {
+       pname = "apecs";
+       version = "0.8.1";
+       sha256 = "10m3lbfg97psnk3z2ml1q9g2ymwa2fnsknrh6ggp9k5c7mskslv0";
+       libraryHaskellDepends = [
+         array base containers mtl template-haskell vector
+       ];
+       testHaskellDepends = [ base containers linear QuickCheck vector ];
+       benchmarkHaskellDepends = [ base criterion linear ];
+       description = "Fast Entity-Component-System library for game programming";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "apecs-gloss" = callPackage
     ({ mkDerivation, apecs, apecs-physics, base, containers, gloss
      , linear
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "apecs-gloss_0_2_1" = callPackage
+    ({ mkDerivation, apecs, apecs-physics, base, containers, gloss
+     , linear
+     }:
+     mkDerivation {
+       pname = "apecs-gloss";
+       version = "0.2.1";
+       sha256 = "0v1nagzwhb1l9wfjl4yp3ymbhbpjcrwrih2y8cxkzws5wxgbbnvg";
+       libraryHaskellDepends = [
+         apecs apecs-physics base containers gloss linear
+       ];
+       description = "Simple gloss renderer for apecs";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "apecs-physics" = callPackage
     ({ mkDerivation, apecs, base, Cabal, containers, inline-c, linear
      , template-haskell, vector
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "apecs-physics_0_4_0" = callPackage
+    ({ mkDerivation, apecs, base, Cabal, containers, inline-c, linear
+     , template-haskell, vector
+     }:
+     mkDerivation {
+       pname = "apecs-physics";
+       version = "0.4.0";
+       sha256 = "0yqylgsl2n0fsb73qdvl1iinazfzzx64683jp37sr2dm8jpys3lc";
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [
+         apecs base containers inline-c linear template-haskell vector
+       ];
+       description = "2D physics for apecs";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "apecs-physics-gloss" = callPackage
     ({ mkDerivation, apecs, apecs-physics, base, gloss }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "apecs-stm";
-       version = "0.1.1";
-       sha256 = "0d0l48fynsk84y2ifb004dpr39s2hdcwrgfp1ds3qff6784sh66b";
+       version = "0.1.2";
+       sha256 = "0wq20ibki20xccp7gvajzfmp90m9vr0sdx55m3ni91j76bsswqg8";
        libraryHaskellDepends = [
          apecs base containers list-t stm stm-containers template-haskell
          vector
···
      }:
      mkDerivation {
        pname = "api-monobank";
-       version = "0.1.2.0";
-       sha256 = "0n9nj6cfszp2wz003sn0xk9533pawlv3afk5p96l6id964dpcdhb";
+       version = "0.1.3.0";
+       sha256 = "0ajp0wv3nkv2db9bx68mq67ag46s2b26p80fx9ypw8nqhnkddg0g";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "DSL for generating API boilerplate and docs";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "api-yoti" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
+     , containers, crypto-pubkey-openssh, crypto-pubkey-types
+     , crypto-simple, cryptonite, directory, hashable, memory, mtl, pem
+     , text, time, transformers, wreq
+     }:
+     mkDerivation {
+       pname = "api-yoti";
+       version = "0.1.0.0";
+       sha256 = "1c2jb9qzfzkcbcxabc7xvqc6npdm23dglpd9zqic7wafm7jdmf0s";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring bytestring containers
+         crypto-pubkey-openssh crypto-pubkey-types crypto-simple cryptonite
+         directory hashable memory mtl pem text time transformers wreq
+       ];
+       testHaskellDepends = [ base bytestring text ];
+       description = "Api bindings for Yoti services";
+       license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "arithmetic";
-       version = "1.2";
-       sha256 = "0yipdx61ky9db46fy2cbal4qc9y94arkcj4z1dj28bx7j7fnmvzk";
+       version = "1.3";
+       sha256 = "09zfwp38ydg7gzivym6k4aid93jm78g1dad04zd0g6zsqb8gpcvb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ats-pkg";
-       version = "3.2.5.17";
-       sha256 = "0ss71fn4d1grasgm1rvg7y4sngfnhsknmf6gxby0yvwfm95fi8aj";
+       version = "3.2.5.18";
+       sha256 = "16v3308zap5jhpd9xsvjdgp28330iscaikdl76jqf5jhb175pxzr";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        doHaddock = false;
        description = "A build tool for ATS";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "ats-setup" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "avro_0_4_5_1" = callPackage
+    ({ mkDerivation, aeson, array, base, base16-bytestring, bifunctors
+     , binary, bytestring, containers, data-binary-ieee754, deepseq
+     , directory, extra, fail, gauge, hashable, hspec, hspec-discover
+     , lens, lens-aeson, mtl, pure-zlib, QuickCheck, random
+     , raw-strings-qq, scientific, semigroups, tagged, template-haskell
+     , text, tf-random, transformers, unordered-containers, vector, zlib
+     }:
+     mkDerivation {
+       pname = "avro";
+       version = "0.4.5.1";
+       sha256 = "1a7ykj2c8bk7y8iaac1076sp4c4qzxh37d97w0xv63srmy7l1r8s";
+       libraryHaskellDepends = [
+         aeson array base base16-bytestring bifunctors binary bytestring
+         containers data-binary-ieee754 deepseq fail hashable mtl scientific
+         semigroups tagged template-haskell text tf-random
+         unordered-containers vector zlib
+       ];
+       testHaskellDepends = [
+         aeson array base base16-bytestring bifunctors binary bytestring
+         containers directory extra fail hashable hspec lens lens-aeson mtl
+         pure-zlib QuickCheck raw-strings-qq scientific semigroups tagged
+         template-haskell text tf-random transformers unordered-containers
+         vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         aeson base bytestring containers gauge hashable mtl random
+         raw-strings-qq text transformers unordered-containers vector
+       ];
+       description = "Avro serialization support for Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "avwx" = callPackage
     ({ mkDerivation, attoparsec, base, HTTP, lens, optparse-applicative
      , parsers, pretty-show, text
···
        pname = "b-tree";
        version = "0.1.4";
        sha256 = "17hcv85020dm5h3449bfa763bcbl723h17chah4418dby2ql5lxg";
+       revision = "1";
+       editedCabalFile = "106vsqgv7545p0rky073sd7viidbg4zy3fzlb39r9irbl3p3giih";
        libraryHaskellDepends = [
          base binary bytestring containers directory errors exceptions
          filepath lens mmap mtl pipes pipes-interleave transformers vector
···
        broken = true;
      }) {};
 
+  "backblaze-b2-hs" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
+     , case-insensitive, conduit, containers, cryptonite, formatting
+     , http-client, http-types, protolude, req, req-conduit, scientific
+     , tasty, tasty-hunit, text, time, unliftio, unliftio-core
+     }:
+     mkDerivation {
+       pname = "backblaze-b2-hs";
+       version = "0.1.0.0";
+       sha256 = "18xpjz3w9yw79732xiz8278gbd1v9vg534l0h9azg0wwhd8vbh7j";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base base64-bytestring bytestring case-insensitive conduit
+         containers cryptonite formatting http-client http-types protolude
+         req req-conduit scientific text time unliftio unliftio-core
+       ];
+       executableHaskellDepends = [
+         aeson base base64-bytestring bytestring case-insensitive conduit
+         containers cryptonite formatting http-client http-types protolude
+         req req-conduit scientific text time unliftio unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson base base64-bytestring bytestring case-insensitive conduit
+         containers cryptonite formatting http-client http-types protolude
+         req req-conduit scientific tasty tasty-hunit text time unliftio
+         unliftio-core
+       ];
+       description = "A client library to access Backblaze B2 cloud storage in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "backdropper" = callPackage
     ({ mkDerivation, base, directory, haskell98, hslogger, old-time
      , process, random
···
        ];
        description = "Heterogeneous automatic differentation";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "backstop" = callPackage
+    ({ mkDerivation, base, directory, filepath, HUnit, mtl, process
+     , QuickCheck, unix
+     }:
+     mkDerivation {
+       pname = "backstop";
+       version = "1.3.0.352";
+       sha256 = "1790n52amkvwlm92rh6i6rxfxbw2n2cfam2sf0cx4yf160jxvyj3";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base directory filepath mtl process unix
+       ];
+       executableHaskellDepends = [
+         base directory filepath mtl process unix
+       ];
+       testHaskellDepends = [
+         base filepath HUnit process QuickCheck unix
+       ];
+       description = "Backstop a target directory by source directories";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "backtracking-exceptions" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "base-unicode-symbols_0_2_4_2" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "base-unicode-symbols";
+       version = "0.2.4.2";
+       sha256 = "0qkhp4ybmx4nbqqkrmw3hkm47bv61i2wpi20qb09wvk10g2dcr23";
+       libraryHaskellDepends = [ base ];
+       description = "Unicode alternatives for common functions and operators";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "base16-bytestring" = callPackage
     ({ mkDerivation, base, bytestring, ghc-prim }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "basement_0_0_11" = callPackage
+    ({ mkDerivation, base, ghc-prim }:
+     mkDerivation {
+       pname = "basement";
+       version = "0.0.11";
+       sha256 = "0srlws74yiraqaapgcjd9p5d1fwb3zr9swcz74jpjm55fls2nn37";
+       libraryHaskellDepends = [ base ghc-prim ];
+       description = "Foundation scrap box of array & string";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "basen-bytestring" = callPackage
     ({ mkDerivation, base, bytestring, QuickCheck }:
      mkDerivation {
···
        ];
        description = "Connection layer between beam and postgres";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "beam-sqlite" = callPackage
···
 
   "bench-show" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, Chart, Chart-diagrams, csv
-     , directory, filepath, mwc-random, split, statistics, text
+     , directory, filepath, mwc-random, optparse-applicative
+     , optparse-simple, semigroups, split, statistics, text
      , transformers, vector
      }:
      mkDerivation {
        pname = "bench-show";
-       version = "0.2.2";
-       sha256 = "12fi59j9a98n4q6gjvjsf0hjc2rsy33b7kzjiqxy5wzh8isciaa4";
+       version = "0.3.0";
+       sha256 = "0c690w96iyj6idikcwl75ci5sqvfh4fdd8mvb4z24x3xb24kirh5";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
          ansi-wl-pprint base Chart Chart-diagrams csv directory filepath
          mwc-random split statistics transformers vector
+       ];
+       executableHaskellDepends = [
+         ansi-wl-pprint base Chart Chart-diagrams csv directory filepath
+         mwc-random optparse-applicative optparse-simple semigroups split
+         statistics transformers vector
        ];
        testHaskellDepends = [ base split text ];
        description = "Show, plot and compare benchmark results";
···
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) wlc;};
+     }) {wlc = null;};
 
   "bindings-yices" = callPackage
     ({ mkDerivation, base, gmp, yices }:
···
      }:
      mkDerivation {
        pname = "birch-beer";
-       version = "0.1.4.0";
-       sha256 = "0vmyp13lxppkar2lgkc231kx7am0h8p2gq6m0swzaz3ra64yh39c";
+       version = "0.1.4.2";
+       sha256 = "02q89rp7f12vf257f2m7g34qwv15027k7gsm4yq95blhi4c5rbg0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "bitvec" = callPackage
-    ({ mkDerivation, base, HUnit, primitive, QuickCheck
-     , quickcheck-classes, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, vector
+    ({ mkDerivation, base, gauge, ghc-prim, primitive
+     , quickcheck-classes, tasty, tasty-hunit, tasty-quickcheck, vector
      }:
      mkDerivation {
        pname = "bitvec";
-       version = "0.2.0.1";
-       sha256 = "0mgmf60gy3nzp66mf4bydls46bddk76rz40zkdfp0hhsspasia9b";
-       libraryHaskellDepends = [ base primitive vector ];
+       version = "1.0.0.0";
+       sha256 = "0m33q70h513iiiwv7w45p4zz7jkf00p5kjy9x3ds6y2rk4di4vl2";
+       libraryHaskellDepends = [ base ghc-prim primitive vector ];
        testHaskellDepends = [
-         base HUnit primitive QuickCheck quickcheck-classes test-framework
-         test-framework-hunit test-framework-quickcheck2 vector
+         base primitive quickcheck-classes tasty tasty-hunit
+         tasty-quickcheck vector
        ];
+       benchmarkHaskellDepends = [ base gauge vector ];
        description = "Unboxed bit vectors";
-       license = stdenv.lib.licenses.publicDomain;
+       license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
      }) {};
 
   "board-games" = callPackage
-    ({ mkDerivation, array, base, cgi, containers, criterion, html
-     , httpd-shed, network-uri, non-empty, QuickCheck, random
-     , transformers, utility-ht
+    ({ mkDerivation, array, base, cgi, containers, criterion
+     , enummapset, html, httpd-shed, network-uri, non-empty, parallel
+     , QuickCheck, random, transformers, utility-ht
      }:
      mkDerivation {
        pname = "board-games";
-       version = "0.2.1";
-       sha256 = "1gsbk1m58f82b1ic0fv1ygslz4lyxxdl0a849q5hl4qbl9s7rbqb";
+       version = "0.3";
+       sha256 = "1ylwibyl0j1v0bdrpfnjhdm431npagavxzgi2l5sp0scgpkcyyx7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         array base cgi containers html non-empty random transformers
-         utility-ht
+         array base cgi containers enummapset html non-empty QuickCheck
+         random transformers utility-ht
        ];
        executableHaskellDepends = [
          array base cgi containers html httpd-shed network-uri non-empty
          random transformers utility-ht
        ];
        testHaskellDepends = [
-         array base containers non-empty QuickCheck random transformers
-         utility-ht
+         array base containers enummapset non-empty QuickCheck random
+         transformers utility-ht
        ];
        benchmarkHaskellDepends = [
-         base containers criterion non-empty utility-ht
+         base containers criterion enummapset non-empty parallel QuickCheck
+         random transformers utility-ht
        ];
        description = "Three games for inclusion in a web server";
        license = "GPL";
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "bogocopy" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "boots" = callPackage
+    ({ mkDerivation, base, data-default, exceptions, fast-logger, hspec
+     , microlens, monad-logger, mtl, salak, salak-yaml, text
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "boots";
+       version = "0.0.3";
+       sha256 = "1glf3hq3vqa3rd115ym7jy5jmwx8mzqbidj875274safg8n552rm";
+       libraryHaskellDepends = [
+         base data-default exceptions fast-logger microlens monad-logger mtl
+         salak salak-yaml text unliftio-core
+       ];
+       testHaskellDepends = [
+         base data-default exceptions fast-logger hspec microlens
+         monad-logger mtl salak salak-yaml text unliftio-core
+       ];
+       description = "Boot application by plugins";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "bootstrap-types" = callPackage
     ({ mkDerivation, base, text }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "box" = callPackage
+    ({ mkDerivation, async, attoparsec, base, concurrency
+     , contravariant, data-default, dejafu, doctest, exceptions, flow
+     , foldl, generic-lens, lens, mmorph, pipes, profunctors, protolude
+     , random, stm, streaming, text, time, transformers
+     , transformers-base
+     }:
+     mkDerivation {
+       pname = "box";
+       version = "0.0.1.2";
+       sha256 = "11g3ig1n1myfgcfvp6gkn5lyr2gdzj4zpginwmjac1c599xiyf8i";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async attoparsec base concurrency contravariant data-default dejafu
+         exceptions flow foldl generic-lens lens mmorph pipes profunctors
+         protolude random stm streaming text time transformers
+         transformers-base
+       ];
+       executableHaskellDepends = [
+         async attoparsec base concurrency contravariant data-default dejafu
+         exceptions flow foldl generic-lens lens mmorph pipes profunctors
+         protolude random stm streaming text time transformers
+         transformers-base
+       ];
+       testHaskellDepends = [
+         async attoparsec base concurrency contravariant data-default dejafu
+         doctest exceptions flow foldl generic-lens lens mmorph pipes
+         profunctors protolude random stm streaming text time transformers
+         transformers-base
+       ];
+       description = "boxes";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "box-tuples" = callPackage
     ({ mkDerivation, base, ghc-prim }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "bv-little_1_0_1" = callPackage
+  "bv-little_1_1_0" = callPackage
     ({ mkDerivation, base, criterion, deepseq, hashable, integer-gmp
      , keys, mono-traversable, mono-traversable-keys, primitive
      , QuickCheck, smallcheck, tasty, tasty-hunit, tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "bv-little";
-       version = "1.0.1";
-       sha256 = "1as21xhzrzcqmrqybczwxhh81avgkmdgn7hhk534dxv6csd7jyp6";
+       version = "1.1.0";
+       sha256 = "1cpmwmd6gig0gggbr197cjpp0ykaj30jniqq3r5lsv644wizkg6r";
        libraryHaskellDepends = [
          base deepseq hashable integer-gmp keys mono-traversable
          mono-traversable-keys primitive QuickCheck text-show
···
      }) {};
 
   "byte-order" = callPackage
-    ({ mkDerivation, base, primitive }:
+    ({ mkDerivation, base, primitive, primitive-unaligned }:
      mkDerivation {
        pname = "byte-order";
-       version = "0.1.0.0";
-       sha256 = "1g0bqx4xzv9y5shjn4wbnrrskahrmybzm1sw1kryyn5z8w7srw34";
-       libraryHaskellDepends = [ base primitive ];
+       version = "0.1.1.0";
+       sha256 = "09j6gkvg1nv05dga46cyxsgnf5ksqbnnsz9nf36xg0vw6c352w7s";
+       libraryHaskellDepends = [ base primitive primitive-unaligned ];
        testHaskellDepends = [ base primitive ];
        description = "Portable big-endian and little-endian conversions";
        license = stdenv.lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
-  "bytestring_0_10_8_2" = callPackage
+  "bytestring_0_10_10_0" = callPackage
     ({ mkDerivation, base, byteorder, deepseq, directory, dlist
      , ghc-prim, HUnit, integer-gmp, mtl, QuickCheck, random
      , test-framework, test-framework-hunit, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "bytestring";
-       version = "0.10.8.2";
-       sha256 = "0fjc5ybxx67l0kh27l6vq4saf88hp1wnssj5ka90ii588y76cvys";
+       version = "0.10.10.0";
+       sha256 = "1h94lyyn4fpklm25dsazj9za08m0vz9irafpza90h9j5wx4qpndq";
        libraryHaskellDepends = [ base deepseq ghc-prim integer-gmp ];
        testHaskellDepends = [
          base byteorder deepseq directory dlist ghc-prim HUnit mtl
···
      }:
      mkDerivation {
        pname = "cabal-cache";
-       version = "1.0.1.0";
-       sha256 = "0x013n44ppwm6vh9n9wch8hki2g3pr2bahngymdm7vd6628jpshz";
+       version = "1.0.1.1";
+       sha256 = "1yb3wvjqqmkm4aysfyx4zf1z88453ywfc4czb4zvghfdgd95d0rx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "cabal-rpm";
        version = "0.12.6";
        sha256 = "1k602v7v87w6xcd9a5m8n5grnjbkyn79rdi9azl7djna0rs129ns";
+       revision = "1";
+       editedCabalFile = "0wfj9gcygm1c9fy86973ybs8ww8g6fn3l7f5v2kvs28204g8i18g";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "cabal-rpm";
        version = "0.13.3";
        sha256 = "04d5m74i0r6livhkhmccrwhshpa2aizyb77i2qcqhxradw0lkvl4";
+       revision = "1";
+       editedCabalFile = "1ngw9afzplbz4q707nak9zcjmk9fdynw0jvis4lgjq02y4i14hj6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "can-i-haz" = callPackage
+    ({ mkDerivation, base, deepseq, hspec, should-not-typecheck }:
+     mkDerivation {
+       pname = "can-i-haz";
+       version = "0.1.0.0";
+       sha256 = "1nsbw6k550n5vc2d17463sjci8a8k2f09519gp8hmdj19a9dlnc7";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base deepseq hspec should-not-typecheck ];
+       description = "Generic implementation of the Has pattern";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "canon" = callPackage
     ({ mkDerivation, arithmoi, array, base, containers, random }:
      mkDerivation {
        pname = "canon";
-       version = "0.1.1.1";
-       sha256 = "0z2s4bk6xs9p2lgg7r70nhr6igvw3z5iarc29slsg0cv9w4232c1";
+       version = "0.1.1.2";
+       sha256 = "181c09kh76104b23hf52b049cc6clww1y9kffw1f0hnkxhds9n84";
        libraryHaskellDepends = [ arithmoi array base containers random ];
        description = "Arithmetic for Psychedelically Large Numbers";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "canonical-filepath" = callPackage
···
      }) {};
 
   "canonical-json" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, parsec
-     , pretty, QuickCheck, tasty, tasty-quickcheck, unordered-containers
-     , vector
+    ({ mkDerivation, aeson, base, bytestring, containers, criterion
+     , deepseq, parsec, pretty, QuickCheck, tasty, tasty-quickcheck
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "canonical-json";
-       version = "0.5.0.1";
-       sha256 = "1r52f69afsnl6kmn0h2rl6wp21jjain4kz6123a1haacfm2f2hwj";
+       version = "0.6.0.0";
+       sha256 = "0lb847hvgkn49g6rvmavk14brvvpiy6q5fswk3cm9rc53hbq02zz";
        libraryHaskellDepends = [
-         base bytestring containers parsec pretty
+         base bytestring containers deepseq parsec pretty
        ];
        testHaskellDepends = [
-         aeson base bytestring QuickCheck tasty tasty-quickcheck
+         aeson base bytestring containers QuickCheck tasty tasty-quickcheck
          unordered-containers vector
        ];
+       benchmarkHaskellDepends = [ base bytestring containers criterion ];
        description = "Canonical JSON for signing and hashing JSON values";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        broken = true;
      }) {};
 
+  "category_0_2_4_1" = callPackage
+    ({ mkDerivation, alg, base, transformers }:
+     mkDerivation {
+       pname = "category";
+       version = "0.2.4.1";
+       sha256 = "0gliy1frgpgyzq3vkin315ylpklfc6dvg0vd93hz8f9m3js6dm48";
+       libraryHaskellDepends = [ alg base transformers ];
+       description = "Categorical types and classes";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "category-extras" = callPackage
     ({ mkDerivation, adjunctions, bifunctors, categories, comonad
      , comonad-extras, comonad-transformers, comonads-fd, contravariant
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "cborg_0_2_2_0" = callPackage
+    ({ mkDerivation, aeson, array, base, base-orphans
+     , base16-bytestring, base64-bytestring, bytestring, containers
+     , deepseq, fail, ghc-prim, half, integer-gmp, primitive, QuickCheck
+     , random, scientific, tasty, tasty-hunit, tasty-quickcheck, text
+     , vector
+     }:
+     mkDerivation {
+       pname = "cborg";
+       version = "0.2.2.0";
+       sha256 = "1rdnvy0w17s70ikmbyrnwax5rvqh19l95sh8i7ipgxi23z1r0bp1";
+       libraryHaskellDepends = [
+         array base bytestring containers deepseq ghc-prim half integer-gmp
+         primitive text
+       ];
+       testHaskellDepends = [
+         aeson array base base-orphans base16-bytestring base64-bytestring
+         bytestring deepseq fail half QuickCheck random scientific tasty
+         tasty-hunit tasty-quickcheck text vector
+       ];
+       description = "Concise Binary Object Representation (CBOR)";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "cborg-json" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, cborg, scientific, text
      , unordered-containers, vector
···
        ];
        description = "A simple and intuitive library for automated testing";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "chell-hunit" = callPackage
···
        libraryHaskellDepends = [ base chell HUnit ];
        description = "HUnit support for the Chell testing library";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "chell-quickcheck" = callPackage
···
        libraryHaskellDepends = [ base chell QuickCheck random ];
        description = "QuickCheck support for the Chell testing library";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "chessIO" = callPackage
···
 
   "chronos" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, clock
-     , criterion, deepseq, hashable, HUnit, old-locale, primitive
-     , QuickCheck, semigroups, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, text, thyme, time, torsor, vector
+     , criterion, deepseq, doctest, hashable, HUnit, old-locale
+     , primitive, QuickCheck, semigroups, test-framework
+     , test-framework-hunit, test-framework-quickcheck2, text, thyme
+     , time, torsor, vector
      }:
      mkDerivation {
        pname = "chronos";
-       version = "1.0.5";
-       sha256 = "0274b5qv1wf52vsdjm1siksh07qgdgid0a9316b7nab2gc7jgpdz";
-       revision = "3";
-       editedCabalFile = "13gjxvybjkgw0qs1vi45b7vs4d2lbh7l76kl8m99dd13dvvb49qf";
+       version = "1.0.6";
+       sha256 = "07z79acmr8768m31knr9r90x0f8xabdkvvyd7y0bv7061562fvdz";
+       revision = "1";
+       editedCabalFile = "156f61rp421x1hisdiq1m7nbaaq4hczfv66v9g94blv3a48rjwzz";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring clock hashable primitive
          semigroups text torsor vector
        ];
        testHaskellDepends = [
-         attoparsec base bytestring HUnit QuickCheck test-framework
-         test-framework-hunit test-framework-quickcheck2 text
+         attoparsec base bytestring doctest HUnit QuickCheck test-framework
+         test-framework-hunit test-framework-quickcheck2 text torsor
        ];
        benchmarkHaskellDepends = [
          attoparsec base bytestring criterion deepseq old-locale QuickCheck
···
      }:
      mkDerivation {
        pname = "clang-pure";
-       version = "0.2.0.4";
-       sha256 = "13c03zj15xx8hq6gqvq62dfqz936mrrz34irk7bqyi0sbhqgrjn1";
+       version = "0.2.0.5";
+       sha256 = "0s84q6qdym02xvva3iq559kmhwzb08slip69h4cvvc6a7lqmaj37";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal inline-c process ];
···
        pname = "colour-space";
        version = "0.1.4.0";
        sha256 = "0sr341chqhngm7ihyy3ym3w345sk101gznw80iksjwxjg3iiqxmq";
-       revision = "1";
-       editedCabalFile = "1n9n76g9zjp1i02f964dlfy65m978m8whbcivd063pf1acp9njax";
+       revision = "2";
+       editedCabalFile = "0qldxm84rk344h4wgk3bqsxfhkmvj8psm0sqgfnjh34a4fy5hjzg";
        libraryHaskellDepends = [
          base colour constrained-categories JuicyPixels linear
          linearmap-category manifolds semigroups vector-space
···
        broken = true;
      }) {};
 
+  "columnar" = callPackage
+    ({ mkDerivation, base, bytestring, cassava, containers, enum-text
+     , fmt, lens, possibly, rio, template-haskell, text, time
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "columnar";
+       version = "1.0.0.0";
+       sha256 = "0qf5fbd9cwc22npww4qsjaj7rxdy2r3rjm19w23a9shqvgc2l6av";
+       libraryHaskellDepends = [
+         base bytestring cassava containers enum-text fmt lens possibly rio
+         template-haskell text time unordered-containers vector
+       ];
+       description = "A CSV toolkit based on cassava and enum-text";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "com" = callPackage
     ({ mkDerivation }:
      mkDerivation {
···
        pname = "constrained-categories";
        version = "0.4.0.0";
        sha256 = "1wq4ivkgxbwxxrfk5lwn2psbbiaq87dr8zf1z9b9yhw2hi75lsgw";
+       revision = "1";
+       editedCabalFile = "0f96xmq5j03f9ks9cjlgbc5wq0azdbrbj2lh3kr3ybz658dli3j7";
        libraryHaskellDepends = [
          base contravariant semigroups tagged trivial-constraint void
        ];
···
      }:
      mkDerivation {
        pname = "constraints-deriving";
-       version = "1.0.4.0";
-       sha256 = "1a78bb8gld07g5m9lwg6phdx3i87pmlk47hic2vbpi9n68kl055v";
+       version = "1.1.0.0";
+       sha256 = "15rspwn8i2rwmqsxb505087ars0i10licwj4adsgm89ajhgrqvp9";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal ];
···
 
   "contiguous" = callPackage
     ({ mkDerivation, base, deepseq, primitive, primitive-unlifted
-     , QuickCheck, quickcheck-instances, vector
+     , QuickCheck, quickcheck-classes, quickcheck-instances, random
+     , random-shuffle, vector, weigh
      }:
      mkDerivation {
        pname = "contiguous";
-       version = "0.4.0.1";
-       sha256 = "1hs9jvl9zzy7jdbxna0aw8nbq3af327xfgb0cgzwmp55iwpjn9rn";
+       version = "0.5";
+       sha256 = "0nz3ssh0zc8rs67mk8fmc8plvbjac6mlxdmzk9fw8sj2vx2ssisq";
        libraryHaskellDepends = [
          base deepseq primitive primitive-unlifted
        ];
        testHaskellDepends = [
-         base primitive QuickCheck quickcheck-instances vector
+         base primitive QuickCheck quickcheck-classes quickcheck-instances
+         vector
+       ];
+       benchmarkHaskellDepends = [
+         base primitive random random-shuffle weigh
        ];
        description = "Unified interface for primitive arrays";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "core-data" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, core-text
+     , hashable, prettyprinter, prettyprinter-ansi-terminal, scientific
+     , text, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "core-data";
+       version = "0.2.0.0";
+       sha256 = "1lzvs99qqw8nvgqqz080zdsxl5vdxdmnffxl8s26c7p41izycp5n";
+       libraryHaskellDepends = [
+         aeson base bytestring containers core-text hashable prettyprinter
+         prettyprinter-ansi-terminal scientific text unordered-containers
+         vector
+       ];
+       description = "Convenience wrappers around common data structures and encodings";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "core-haskell" = callPackage
     ({ mkDerivation, base, haskeline, haskell-src-exts, hint }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
+     }) {};
+
+  "core-program" = callPackage
+    ({ mkDerivation, async, base, bytestring, chronologique, core-data
+     , core-text, directory, exceptions, hashable, hourglass, mtl
+     , prettyprinter, prettyprinter-ansi-terminal, safe-exceptions, stm
+     , template-haskell, terminal-size, text, text-short, transformers
+     , unix
+     }:
+     mkDerivation {
+       pname = "core-program";
+       version = "0.2.0.0";
+       sha256 = "13907wk5p8yc31wf7s3w6an8g2b5j8pp0k196l5fh90c5dadizys";
+       libraryHaskellDepends = [
+         async base bytestring chronologique core-data core-text directory
+         exceptions hashable hourglass mtl prettyprinter
+         prettyprinter-ansi-terminal safe-exceptions stm template-haskell
+         terminal-size text text-short transformers unix
+       ];
+       description = "Opinionated Haskell Interoperability";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "core-text" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, fingertree, hashable
+     , prettyprinter, prettyprinter-ansi-terminal, template-haskell
+     , text, text-short
+     }:
+     mkDerivation {
+       pname = "core-text";
+       version = "0.2.0.0";
+       sha256 = "1rkbz43vnjv8vv68xh98qcp59lmahw4sdpfnhvgrh92wj0namifk";
+       libraryHaskellDepends = [
+         base bytestring deepseq fingertree hashable prettyprinter
+         prettyprinter-ansi-terminal template-haskell text text-short
+       ];
+       description = "A text type based on a finger tree over UTF-8 fragments";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "corebot-bliki" = callPackage
···
      }) {};
 
   "cpkg" = callPackage
-    ({ mkDerivation, base, binary, bytestring, bzlib, containers, cpphs
-     , dhall, dir-traverse, directory, filemanip, filepath, hashable
-     , hspec, hspec-megaparsec, http-client, http-client-tls, libarchive
-     , lzma, megaparsec, microlens, mtl, network-uri
-     , optparse-applicative, prettyprinter, process, recursion, tar
-     , temporary, text, zip-archive, zlib
+    ({ mkDerivation, base, binary, bytestring, bzlib
+     , composition-prelude, containers, cpphs, dhall, dir-traverse
+     , directory, filemanip, filepath, hashable, hspec, hspec-megaparsec
+     , http-client, http-client-tls, libarchive, lzma, megaparsec
+     , microlens, mtl, network-uri, optparse-applicative, prettyprinter
+     , process, recursion, tar, temporary, text, zip-archive, zlib
      }:
      mkDerivation {
        pname = "cpkg";
-       version = "0.2.1.0";
-       sha256 = "0wwfdw4qvgf25zych8pvknx99pr4zrxknyi80laqx7b7w5l0rnvc";
+       version = "0.2.3.1";
+       sha256 = "0nw1h6zgx3dizx92nwzdf9ny8bzyfa2n28lpv34xvw38fz9yq16w";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base binary bytestring bzlib containers dhall dir-traverse
-         directory filemanip filepath hashable http-client http-client-tls
-         libarchive lzma megaparsec microlens mtl network-uri prettyprinter
-         process recursion tar temporary text zip-archive zlib
+         base binary bytestring bzlib composition-prelude containers dhall
+         dir-traverse directory filemanip filepath hashable http-client
+         http-client-tls libarchive lzma megaparsec microlens mtl
+         network-uri prettyprinter process recursion tar temporary text
+         zip-archive zlib
        ];
        libraryToolDepends = [ cpphs ];
        executableHaskellDepends = [
···
        broken = true;
      }) {};
 
-  "cql-io_1_1_0" = callPackage
+  "cql-io_1_1_1" = callPackage
     ({ mkDerivation, async, auto-update, base, bytestring, containers
      , cql, cryptonite, data-default-class, Decimal, exceptions
      , hashable, HsOpenSSL, iproute, lens, mtl, mwc-random, network
···
      }:
      mkDerivation {
        pname = "cql-io";
-       version = "1.1.0";
-       sha256 = "1pqqq31f9xcpn5rykkgrakgl17dm1nnskh1m88fxaynzjj485pkw";
-       revision = "1";
-       editedCabalFile = "0zxc28i4c26qi6xpgsyhn0f539ni6wv6c1pixh056bzm9pwp60d7";
+       version = "1.1.1";
+       sha256 = "1zg199ifkqh1ba335vqp0jlm4sn5ybjxap4qymb54bylhwj0vzcp";
        libraryHaskellDepends = [
          async auto-update base bytestring containers cql cryptonite
          data-default-class exceptions hashable HsOpenSSL iproute lens mtl
···
        ];
        description = "Robust, reliable performance measurement and analysis";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "criterion-compare" = callPackage
+    ({ mkDerivation, base, bytestring, cassava, Chart, Chart-diagrams
+     , clay, colour, containers, data-default, filepath, lens, lucid
+     , optparse-applicative, text, vector
+     }:
+     mkDerivation {
+       pname = "criterion-compare";
+       version = "0.1.0.0";
+       sha256 = "034cm3hap9x6cwp44hrd03b09mifcm076a9pn3lgql5ardx91yl7";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base bytestring cassava Chart Chart-diagrams clay colour containers
+         data-default filepath lens lucid optparse-applicative text vector
+       ];
+       description = "A simple tool for visualising differences in Criterion benchmark results";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "criterion-measurement" = callPackage
···
     ({ mkDerivation, base, deepseq, QuickCheck }:
      mkDerivation {
        pname = "data-clist";
-       version = "0.1.2.2";
-       sha256 = "1aibiml1vs983lbxq18zcn9h11k3zjrxpsx4rxssqdjwni1kg9yi";
+       version = "0.1.2.3";
+       sha256 = "1mwfhnmvi3vicyjzl33m6pcipi2v887zazyqxygq258ndd010s9m";
        libraryHaskellDepends = [ base deepseq QuickCheck ];
        description = "Simple functional ring type";
        license = stdenv.lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
+  "database-id-class" = callPackage
+    ({ mkDerivation, aeson, base }:
+     mkDerivation {
+       pname = "database-id-class";
+       version = "0.1.0.1";
+       sha256 = "0zm053ll1vwd5gdwq4p3zpl9f010q894nk3djaad3ry4y2mirsc4";
+       libraryHaskellDepends = [ aeson base ];
+       description = "Class for types with a database id";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "database-id-groundhog" = callPackage
+    ({ mkDerivation, aeson, base, database-id-class, groundhog
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "database-id-groundhog";
+       version = "0.1.0.1";
+       sha256 = "16q90lzxjbisfdvcl4lbjlfmn02xnscsxkv9hm35xw9z8q19zlsx";
+       libraryHaskellDepends = [
+         aeson base database-id-class groundhog template-haskell
+       ];
+       description = "HasId/Groundhog interop";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "database-migrate" = callPackage
     ({ mkDerivation, base, bytestring, cmdargs, containers, directory
      , either, filepath, lens, postgresql-simple, text, time
···
        pname = "datadog-tracing";
        version = "1.5.1";
        sha256 = "1jjgavp9winbl2gyix61y30myvzhvzb500l2zwcb087cqzy7z6nb";
+       revision = "2";
+       editedCabalFile = "1mb0g3lddphaki1q946dpayhjdma9g0xcx55wdmksbhkjrbm0rgb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "decimal-literals";
        version = "0.1.0.1";
        sha256 = "0lbpnc4c266fbqjzzrnig648zzsqfaphlxqwyly9xd15qggzasb0";
+       revision = "1";
+       editedCabalFile = "0giz73yb179xvww1s92dbl4mhvcxlv25f0zrjwc9lsvx9h2aivg0";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Preprocessing decimal literals more or less as they are (instead of via fractions)";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall_1_24_0" = callPackage
+  "dhall_1_25_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, base
      , bytestring, case-insensitive, cborg, cborg-json, containers
-     , contravariant, criterion, cryptonite, deepseq, Diff, directory
-     , doctest, dotgen, exceptions, filepath, foldl, haskeline
+     , contravariant, cryptonite, deepseq, Diff, directory, doctest
+     , dotgen, either, exceptions, filepath, foldl, gauge, haskeline
      , http-client, http-client-tls, http-types, lens-family-core
      , megaparsec, memory, mockery, mtl, optparse-applicative, parsers
      , prettyprinter, prettyprinter-ansi-terminal, profunctors
-     , QuickCheck, quickcheck-instances, repline, scientific, serialise
-     , tasty, tasty-hunit, tasty-quickcheck, template-haskell, text
-     , transformers, transformers-compat, turtle, unordered-containers
-     , uri-encode, vector
+     , QuickCheck, quickcheck-instances, repline, scientific, semigroups
+     , serialise, spoon, tasty, tasty-hunit, tasty-quickcheck
+     , template-haskell, text, th-lift-instances, transformers
+     , transformers-compat, turtle, unordered-containers, uri-encode
+     , vector
      }:
      mkDerivation {
        pname = "dhall";
-       version = "1.24.0";
-       sha256 = "1n04jk45qjl00wx7gxzp36j7d1m1ca7h7y4qlp8gxhykpkr6zzv7";
-       revision = "1";
-       editedCabalFile = "1b0gqva12rh0fynddal7q8jy6i3yax79br8xbfp9kh7936w9cs1j";
+       version = "1.25.0";
+       sha256 = "0d8qx4fawvxykig628jfgqpa660mzzicysa7g3mda6zni9j4yq0h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty ansi-terminal base bytestring case-insensitive
-         cborg cborg-json containers contravariant cryptonite Diff directory
-         dotgen exceptions filepath haskeline http-client http-client-tls
-         http-types lens-family-core megaparsec memory mtl
+         cborg cborg-json containers contravariant cryptonite deepseq Diff
+         directory dotgen either exceptions filepath haskeline http-client
+         http-client-tls http-types lens-family-core megaparsec memory mtl
          optparse-applicative parsers prettyprinter
          prettyprinter-ansi-terminal profunctors repline scientific
-         serialise template-haskell text transformers transformers-compat
-         unordered-containers uri-encode vector
+         serialise template-haskell text th-lift-instances transformers
+         transformers-compat unordered-containers uri-encode vector
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
          base bytestring cborg containers deepseq directory doctest filepath
-         foldl megaparsec mockery prettyprinter QuickCheck
-         quickcheck-instances serialise tasty tasty-hunit tasty-quickcheck
-         text transformers turtle vector
+         foldl lens-family-core megaparsec mockery prettyprinter QuickCheck
+         quickcheck-instances semigroups serialise spoon tasty tasty-hunit
+         tasty-quickcheck text transformers turtle vector
        ];
        benchmarkHaskellDepends = [
-         base bytestring containers criterion directory serialise text
+         base bytestring containers directory gauge serialise text
        ];
        description = "A configuration language guaranteed to terminate";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall-bash_1_0_21" = callPackage
+  "dhall-bash_1_0_22" = callPackage
     ({ mkDerivation, base, bytestring, containers, dhall
      , neat-interpolation, optparse-generic, shell-escape, text
      }:
      mkDerivation {
        pname = "dhall-bash";
-       version = "1.0.21";
-       sha256 = "06rv0wrs1ym6szy78wg3nyfwaqm279vy6m7zny9s90lnpa6dc098";
+       version = "1.0.22";
+       sha256 = "1qxcf3f8a390znwkbhcirlgqpgg0ssc3bnwdml7wkv8k0qwqq57j";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall-json_1_3_0" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
-     , dhall, exceptions, lens, libyaml, optparse-applicative
+  "dhall-json_1_4_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, base
+     , bytestring, containers, dhall, exceptions, libyaml
+     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
      , scientific, tasty, tasty-hunit, text, unordered-containers
      , vector, yaml
      }:
      mkDerivation {
        pname = "dhall-json";
-       version = "1.3.0";
-       sha256 = "176i30shaklranbhmb4m4zqn13cn9hd6lqiqdjv9qmckkapbkjpi";
-       revision = "1";
-       editedCabalFile = "101xfp3zg9i7qyibknjpcdhha8sc024xmylphiwb509h3fjy3yks";
+       version = "1.4.0";
+       sha256 = "0kxb71m1rf6y7z3wx4yx5ks0p5vhnlpgchsih3mfn9ygppc2z0ri";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson aeson-pretty base bytestring containers dhall exceptions lens
+         aeson aeson-pretty base bytestring containers dhall exceptions
          libyaml optparse-applicative scientific text unordered-containers
          vector yaml
        ];
        executableHaskellDepends = [
-         aeson aeson-pretty base bytestring dhall exceptions
-         optparse-applicative text
+         aeson aeson-pretty ansi-terminal base bytestring dhall exceptions
+         optparse-applicative prettyprinter prettyprinter-ansi-terminal text
        ];
        testHaskellDepends = [
          aeson base bytestring dhall tasty tasty-hunit text
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "dhall-lsp-server" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
+     , cryptonite, data-default, dhall, dhall-json, directory, doctest
+     , dotgen, filepath, haskell-lsp, hslogger, lens, lens-family-core
+     , megaparsec, mtl, network-uri, optparse-applicative, prettyprinter
+     , sorted-list, stm, text, transformers, unordered-containers
+     , uri-encode, yi-rope
+     }:
+     mkDerivation {
+       pname = "dhall-lsp-server";
+       version = "1.0.0";
+       sha256 = "1i4bx8qiy1hbs6bm50fixj1ipkd9rm6y6z3bci8ngh1rhy5v51x1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring containers cryptonite
+         data-default dhall dhall-json dotgen filepath haskell-lsp hslogger
+         lens lens-family-core megaparsec mtl network-uri
+         optparse-applicative prettyprinter sorted-list stm text
+         transformers unordered-containers uri-encode yi-rope
+       ];
+       executableHaskellDepends = [
+         aeson base containers data-default dhall filepath haskell-lsp
+         hslogger lens lens-family-core megaparsec mtl optparse-applicative
+         prettyprinter sorted-list stm text transformers
+         unordered-containers yi-rope
+       ];
+       testHaskellDepends = [ base directory doctest filepath ];
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "dhall-nix" = callPackage
     ({ mkDerivation, base, containers, data-fix, dhall, hnix
-     , insert-ordered-containers, neat-interpolation, optparse-generic
-     , text
+     , neat-interpolation, optparse-generic, text
      }:
      mkDerivation {
        pname = "dhall-nix";
-       version = "1.1.6";
-       sha256 = "0pchanzgcag6z7fywqm09xj29n0pfxd2ya2ky64aapykq038jxbs";
+       version = "1.1.7";
+       sha256 = "0axg7qq8rfy5qsffiw57lll40mw7bxgk67g7lgdb5vbri69xj3is";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers data-fix dhall hnix insert-ordered-containers
-         neat-interpolation text
+         base containers data-fix dhall hnix neat-interpolation text
        ];
        executableHaskellDepends = [
          base dhall hnix optparse-generic text
···
        ];
        description = "Compile Dhall expressions to Cabal files";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "dhcp-lease-parser" = callPackage
···
        ];
        description = "Parse a DHCP lease file";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "dhrun" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, conduit
+     , conduit-extra, containers, dhall, directory, editor-open
+     , filepath, generic-random, Glob, hspec, mtl, optparse-applicative
+     , process, protolude, quickcheck-text, tasty, tasty-golden
+     , tasty-hspec, tasty-hunit, tasty-quickcheck, text, time, unix
+     , unliftio, unliftio-core, yaml
+     }:
+     mkDerivation {
+       pname = "dhrun";
+       version = "1.0.1";
+       sha256 = "1gyg5221g1qsq2h62lcdwi4g7amis26692hh3fdi824bjylz8pal";
+       isLibrary = false;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-terminal base bytestring conduit conduit-extra containers
+         dhall directory mtl process protolude text time unix unliftio-core
+         yaml
+       ];
+       executableHaskellDepends = [
+         base bytestring dhall directory editor-open filepath
+         optparse-applicative protolude
+       ];
+       testHaskellDepends = [
+         aeson base bytestring dhall filepath generic-random Glob hspec mtl
+         protolude quickcheck-text tasty tasty-golden tasty-hspec
+         tasty-hunit tasty-quickcheck text unliftio yaml
+       ];
+       doHaddock = false;
+       description = "Dhall/YAML configurable concurrent integration test executor";
+       license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
 
   "discord-haskell" = callPackage
     ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring
-     , containers, data-default, http-client, iso8601-time, JuicyPixels
-     , MonadRandom, req, safe-exceptions, text, time
+     , containers, data-default, emoji, http-client, iso8601-time
+     , JuicyPixels, MonadRandom, req, safe-exceptions, text, time
      , unordered-containers, vector, websockets, wuss
      }:
      mkDerivation {
        pname = "discord-haskell";
-       version = "0.8.4";
-       sha256 = "1x2rqnvmxcyf320l0vyrj2dw5p1nql588zp8nknnwpk0sp0dxmjm";
+       version = "1.0.0";
+       sha256 = "1z0d46gd7rgwbh05ws6hcp4rikach0yg1fim6ni0ww4g0mksj8j3";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
          aeson async base base64-bytestring bytestring containers
-         data-default http-client iso8601-time JuicyPixels MonadRandom req
-         safe-exceptions text time unordered-containers vector websockets
-         wuss
+         data-default emoji http-client iso8601-time JuicyPixels MonadRandom
+         req safe-exceptions text time unordered-containers vector
+         websockets wuss
        ];
+       executableHaskellDepends = [ base text ];
        description = "Write bots for Discord in Haskell";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "discord-hs" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "ditto" = callPackage
+    ({ mkDerivation, base, containers, mtl, semigroups, text }:
+     mkDerivation {
+       pname = "ditto";
+       version = "0.3.1";
+       sha256 = "1y3s0q0c0lsj6hsszazbd0yjb10nagvg96nw3x154kz55mn2bdym";
+       libraryHaskellDepends = [ base containers mtl semigroups text ];
+       description = "ditto is a type-safe HTML form generation and validation library";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "ditto-lucid" = callPackage
+    ({ mkDerivation, base, ditto, lucid, path-pieces, text }:
+     mkDerivation {
+       pname = "ditto-lucid";
+       version = "0.3.2";
+       sha256 = "1asp25vi3m6rbk1wllqb1gzjrgifndhcpr2blx1j132ql6h5qqpj";
+       libraryHaskellDepends = [ base ditto lucid path-pieces text ];
+       description = "Add support for using lucid with Ditto";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "diversity" = callPackage
     ({ mkDerivation, base, containers, data-ordlist, fasta
      , math-functions, MonadRandom, optparse-applicative, parsec, pipes
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "dns_4_0_0" = callPackage
+    ({ mkDerivation, array, async, attoparsec, auto-update, base
+     , base16-bytestring, base64-bytestring, bytestring, Cabal
+     , cabal-doctest, containers, cryptonite, doctest, hourglass, hspec
+     , iproute, mtl, network, psqueues, QuickCheck, word8
+     }:
+     mkDerivation {
+       pname = "dns";
+       version = "4.0.0";
+       sha256 = "0gq0y8pw4x8fja0f3hhwpbxh4rg2i8nzfnp2rxh2py49qfhg38mj";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         array async attoparsec auto-update base base16-bytestring
+         base64-bytestring bytestring containers cryptonite hourglass
+         iproute mtl network psqueues
+       ];
+       testHaskellDepends = [
+         base bytestring doctest hspec iproute network QuickCheck word8
+       ];
+       testTarget = "spec";
+       description = "DNS library in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "dnscache" = callPackage
     ({ mkDerivation, base, bytestring, containers, contstuff, dns
      , iproute, time
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "doctemplates_0_3_0_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, filepath
+     , Glob, mtl, parsec, scientific, tasty, tasty-golden, tasty-hunit
+     , temporary, text, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "doctemplates";
+       version = "0.3.0.1";
+       sha256 = "11xvrmk9qb2izq8y61pna0lxlsfr5yb94nlk5ih8z1fcdn7ghl3j";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base containers filepath mtl parsec scientific text
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring filepath Glob mtl tasty tasty-golden
+         tasty-hunit temporary text
+       ];
+       description = "Pandoc-style document templates";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "doctest" = callPackage
     ({ mkDerivation, base, base-compat, code-page, deepseq, directory
      , filepath, ghc, ghc-paths, hspec, HUnit, mockery, process
···
        broken = true;
      }) {};
 
+  "doldol" = callPackage
+    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
+     , test-framework-hunit, test-framework-quickcheck2
+     , test-framework-th
+     }:
+     mkDerivation {
+       pname = "doldol";
+       version = "0.4.1.2";
+       sha256 = "0r9ylifyyv2mg4b94ikv8q56j0z5f6qa8r2jcpqg0xzdznwxqlv5";
+       revision = "1";
+       editedCabalFile = "0xwbdrfzd6z3nwkgnav2drisw2sn464ggkz8fid58cym9hbfpl47";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base HUnit QuickCheck test-framework test-framework-hunit
+         test-framework-quickcheck2 test-framework-th
+       ];
+       description = "Flag packer & handler for flaggable data";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "dollaridoos" = callPackage
     ({ mkDerivation, base, profunctors, semigroups }:
      mkDerivation {
···
        broken = true;
      }) {};
 
-  "dotenv_0_8_0_1" = callPackage
+  "dotenv_0_8_0_2" = callPackage
     ({ mkDerivation, base, base-compat, containers, directory
      , exceptions, hspec, hspec-megaparsec, megaparsec
      , optparse-applicative, process, text, transformers, yaml
      }:
      mkDerivation {
        pname = "dotenv";
-       version = "0.8.0.1";
-       sha256 = "1mp6j3wcxiz75yjf9bnb4kc5gw09v0ax1fz0hhh9i2glxi53m27l";
+       version = "0.8.0.2";
+       sha256 = "0an7spi0cgvzr64nyy7p8pdslyf0jlh9l2ww52jbh1habsxjn6fp";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "dumb-cas";
        version = "0.2.0.0";
        sha256 = "1zcq9r2p5gjpfivprjp9hspqpayrj9in2jck5vf5ibxpc671isb4";
+       revision = "1";
+       editedCabalFile = "1269wjyywvi86gmpqdpq2niv5ifns0bqr1i5229w69jdlzrc6dqg";
        libraryHaskellDepends = [
          base containers decimal-literals hashable template-haskell
          unordered-containers
···
      }:
      mkDerivation {
        pname = "dynamic-graph";
-       version = "0.1.0.12";
-       sha256 = "1jygkj2jryjxlkyf0104abhkhjmfdvjaaa4zcyz7kgpny342fhiy";
+       version = "0.1.0.13";
+       sha256 = "1gx3hqbps8mvhxm03j5wri7v4qy3z42kcy8rhhcxq7dd0mryd4rz";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base cairo colour GLFW-b GLUtil OpenGL pango pipes transformers
···
        pname = "dynamic-plot";
        version = "0.4.0.0";
        sha256 = "1klq7lwvfwwp6z842g50a2xx6cqihp8a6551f935nr2sx9hwdr94";
+       revision = "1";
+       editedCabalFile = "0x5jxjvwfkax6lxwk28hd2p903q6zmr1nxhyahrwcnqgh6ygywiw";
        libraryHaskellDepends = [
          base colour colour-space constrained-categories containers
          data-default deepseq diagrams-cairo diagrams-core diagrams-gtk
···
     ({ mkDerivation, base, constraints, mtl, transformers }:
      mkDerivation {
        pname = "effect-stack";
-       version = "0.2.1";
-       sha256 = "0sram572nbzpgwb3vi5fmg2f4ynsh693q05w0n5yjj8zl4a7p4ds";
+       version = "0.3";
+       sha256 = "08zalj8svp78ykqbf5nhd6khgygz8dplcvjd19w3hvgm08y4kxqi";
        libraryHaskellDepends = [ base constraints mtl transformers ];
        description = "Reducing the pain of transformer stacks with duplicated effects";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "egison" = callPackage
-    ({ mkDerivation, array, base, containers, criterion, deepseq
-     , directory, filepath, ghc, ghc-paths, Glob, hashable, haskeline
-     , HUnit, lens, mtl, parallel, parsec, process, random, regex-tdfa
-     , split, test-framework, test-framework-hunit, text, transformers
-     , unordered-containers, vector
+    ({ mkDerivation, alex, array, base, containers, criterion, deepseq
+     , directory, filepath, ghc, ghc-paths, Glob, happy, hashable
+     , haskeline, HUnit, mtl, optparse-applicative, parallel, parsec
+     , process, random, regex-tdfa, split, test-framework
+     , test-framework-hunit, text, transformers, unordered-containers
+     , vector
      }:
      mkDerivation {
        pname = "egison";
-       version = "3.8.2";
-       sha256 = "090zhf89faakidbf8kkbsa8ck0rl7fqbpg3fwymjqlafgnfx1jc2";
+       version = "3.9.0";
+       sha256 = "1law6pwgqvp6nniwwbbsdm6fjq2fp30ywjfla2qqgwdabcqbd2vq";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base containers directory ghc ghc-paths hashable haskeline
-         lens mtl parallel parsec process random regex-tdfa split text
+         mtl parallel parsec process random regex-tdfa split text
          transformers unordered-containers vector
        ];
+       libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [
          array base containers directory filepath ghc ghc-paths haskeline
-         mtl parsec process regex-tdfa text transformers
-         unordered-containers vector
+         mtl optparse-applicative parsec process regex-tdfa text
+         transformers unordered-containers vector
        ];
        testHaskellDepends = [
          base filepath Glob HUnit mtl test-framework test-framework-hunit
···
        ];
        description = "Programming language with non-linear pattern-matching against non-free data";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "egison-quote" = callPackage
···
      }:
      mkDerivation {
        pname = "engine-io-wai";
-       version = "1.0.9";
-       sha256 = "1zdin34gfi2059n1wjfxs4i2kfc0r53f3wpwhjd0fbp0as56h94s";
+       version = "1.0.10";
+       sha256 = "07vjjb7d5ndv8cailnrv5qif0d3kmi09bq1s38hwjyp5ml8dlfis";
        libraryHaskellDepends = [
          attoparsec base bytestring either engine-io http-types mtl text
          transformers transformers-compat unordered-containers wai
···
        ];
        description = "A text rendering and parsing toolkit for enumerated types";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "enum-text_0_5_1_0" = callPackage
+    ({ mkDerivation, array, base, bytestring, fmt, hashable, possibly
+     , text, time, unordered-containers
+     }:
+     mkDerivation {
+       pname = "enum-text";
+       version = "0.5.1.0";
+       sha256 = "0v48hmxbpzjpclg1q0avrc1dp4giglbxy2rkqnbj4f0sprp03kff";
+       libraryHaskellDepends = [
+         array base bytestring fmt hashable possibly text time
+         unordered-containers
+       ];
+       description = "A text rendering and parsing toolkit for enumerated types";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "enum-text-rio" = callPackage
+    ({ mkDerivation, base, bytestring, enum-text, fmt, rio, text }:
+     mkDerivation {
+       pname = "enum-text-rio";
+       version = "1.2.0.0";
+       sha256 = "0cz91i1m9ibphlm153i23i03nhx41bca398hkfzf9hq904ziarna";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base bytestring enum-text fmt rio text ];
+       executableHaskellDepends = [
+         base bytestring enum-text fmt rio text
+       ];
+       description = "Making fmt available with rio";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "enum-types" = callPackage
···
        pname = "enummapset";
        version = "0.6.0.1";
        sha256 = "0nljpb5fxk4piwl5mh1v23ps9bzhxxcybfhd8mmb66k20gxxxf7q";
+       libraryHaskellDepends = [ base containers deepseq semigroups ];
+       testHaskellDepends = [
+         array base containers deepseq ghc-prim HUnit QuickCheck semigroups
+         test-framework test-framework-hunit test-framework-quickcheck2
+       ];
+       description = "IntMap and IntSet with Enum keys/elements";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "enummapset_0_6_0_2" = callPackage
+    ({ mkDerivation, array, base, containers, deepseq, ghc-prim, HUnit
+     , QuickCheck, semigroups, test-framework, test-framework-hunit
+     , test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "enummapset";
+       version = "0.6.0.2";
+       sha256 = "0476rzarcfpp4qm4qsz6wdnhr11nlfhqgrnbni591kbmngqlld1v";
        libraryHaskellDepends = [ base containers deepseq semigroups ];
        testHaskellDepends = [
          array base containers deepseq ghc-prim HUnit QuickCheck semigroups
···
        pname = "explicit-constraint-lens";
        version = "0.1.0.0";
        sha256 = "181frvmgv65rcjpiya4gswvpq9ahz97c8lalhgmwknx9jx5nqd98";
+       revision = "1";
+       editedCabalFile = "06mj6zxj1l439g6l5ibrxbsr6ff2c199i3dlf0k1yxjck1dfblv4";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Fully-flexible polymorphic lenses, without any bizarre profunctors";
···
      }) {};
 
   "extensible" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, cassava, comonad
+    ({ mkDerivation, aeson, barbies, base, bytestring, cassava, comonad
      , constraints, deepseq, exceptions, ghc-prim, hashable, lens
      , membership, monad-skeleton, mtl, prettyprinter, primitive
      , profunctors, QuickCheck, resourcet, StateVar, tagged
···
      }:
      mkDerivation {
        pname = "extensible";
-       version = "0.5.1";
-       sha256 = "0rqq2pwp5zzpl9xzjmk0m8a54mbs10d7dywswfd84wqrngknkp10";
+       version = "0.6";
+       sha256 = "14cqsg4lamnhbdccdc0wfwzjzkpj93g92s93wmpg4214ykvr2gvf";
        libraryHaskellDepends = [
-         aeson base bytestring cassava comonad constraints deepseq
+         aeson barbies base bytestring cassava comonad constraints deepseq
          exceptions ghc-prim hashable membership monad-skeleton mtl
          prettyprinter primitive profunctors QuickCheck resourcet StateVar
          tagged template-haskell text th-lift transformers
···
      }) {};
 
   "extensible-effects-concurrent" = callPackage
-    ({ mkDerivation, async, base, bytestring, containers, data-default
-     , deepseq, directory, exceptions, extensible-effects, filepath
-     , hostname, HUnit, lens, monad-control, mtl, network, parallel
-     , pretty-types, process, QuickCheck, safe-exceptions, stm, tagged
-     , tasty, tasty-discover, tasty-hunit, text, time, transformers-base
+    ({ mkDerivation, async, base, containers, data-default, deepseq
+     , directory, exceptions, extensible-effects, filepath, hashable
+     , hostname, HUnit, lens, monad-control, mtl, network, pretty-types
+     , QuickCheck, safe-exceptions, stm, tasty, tasty-discover
+     , tasty-hunit, text, time, transformers-base
      }:
      mkDerivation {
        pname = "extensible-effects-concurrent";
-       version = "0.29.2";
-       sha256 = "0a2nbnr8giil05jy5nr7d3gy3cgvq9058dzqb49as65n232n1iv1";
+       version = "0.32.0";
+       sha256 = "1zipam9jac1bj4fkzihgh0hasiwgpycidhvxb0b2b0q7ic18487a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         async base bytestring containers data-default deepseq directory
-         exceptions extensible-effects filepath hostname lens monad-control
-         mtl network parallel pretty-types process QuickCheck
-         safe-exceptions stm tagged text time transformers-base
+         async base containers data-default deepseq directory exceptions
+         extensible-effects filepath hashable hostname lens monad-control
+         mtl network pretty-types safe-exceptions stm text time
+         transformers-base
        ];
        executableHaskellDepends = [
-         base data-default deepseq directory extensible-effects filepath
-         lens pretty-types text
+         base data-default deepseq extensible-effects lens pretty-types text
        ];
        testHaskellDepends = [
          async base containers data-default deepseq extensible-effects
-         filepath hostname HUnit lens pretty-types QuickCheck stm tasty
-         tasty-discover tasty-hunit text time
+         filepath hostname HUnit lens monad-control pretty-types QuickCheck
+         stm tasty tasty-discover tasty-hunit text time
        ];
        testToolDepends = [ tasty-discover ];
        description = "Message passing concurrency as extensible-effect";
···
        broken = true;
      }) {};
 
+  "f-algebra-gen" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "f-algebra-gen";
+       version = "0.1.0.2";
+       sha256 = "1vxhfr4wqm2bclnq15lp4q496w3916ll9chj6mcqbn0r64bmmkn8";
+       libraryHaskellDepends = [ base template-haskell ];
+       description = "Generate a special f-algebra combinator from any data type";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "f-ree-hack-cheats-free-v-bucks-generator" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
     ({ mkDerivation, base, containers, hspec, mtl, QuickCheck }:
      mkDerivation {
        pname = "fakefs";
-       version = "0.2.0.0";
-       sha256 = "0r20w8grmcfr5vwh8j2kfg9lm9pkcq9cvgnrw1sj2vi38s96icwx";
+       version = "0.2.0.1";
+       sha256 = "0szdjrc4m87h9dsb7qg5rpp5avnyzv47mymyihgvmxc22wiyf1c1";
        libraryHaskellDepends = [ base containers mtl ];
        testHaskellDepends = [ base containers hspec QuickCheck ];
        description = "Extensible fake file system for testing";
···
        pname = "fedora-haskell-tools";
        version = "0.8";
        sha256 = "03wk335dpkbcdgxqsjiavnqc43jkw8gh7y41dyfwivwd9mr32y2w";
+       revision = "1";
+       editedCabalFile = "06xak96g91krd45kvz1nscnfn4rw9gdj5xxwn8simb2vmqiy6f94";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "feed_1_1_0_0" = callPackage
+  "feed_1_2_0_0" = callPackage
     ({ mkDerivation, base, base-compat, bytestring, HUnit
      , markdown-unlit, old-locale, old-time, safe, test-framework
      , test-framework-hunit, text, time, time-locale-compat, utf8-string
···
      }:
      mkDerivation {
        pname = "feed";
-       version = "1.1.0.0";
-       sha256 = "05hiasa6k13v1pzp9cs991zh04njda0ax9868rc7k906b19qqkjg";
-       revision = "1";
-       editedCabalFile = "0bn0vnn6v373ycrbxwqzp1ncmq649h13f2na8q8yf0i68mxampks";
+       version = "1.2.0.0";
+       sha256 = "0cakrlq1ra2gwyqmdhss4clkj0xxrwy3pc4xjzgqz4w3yd1czjg7";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base base-compat bytestring old-locale old-time safe text time
···
      }) {};
 
   "flags-applicative" = callPackage
-    ({ mkDerivation, base, containers, hspec, mtl, network, text }:
+    ({ mkDerivation, base, casing, containers, hspec, mtl, network
+     , text
+     }:
      mkDerivation {
        pname = "flags-applicative";
-       version = "0.0.5.2";
-       sha256 = "1yjwnh6mqq3ypc3rs7a13j998zizfn6fn35d2wijdkm4ahyjpjhv";
-       libraryHaskellDepends = [ base containers mtl network text ];
-       testHaskellDepends = [ base hspec text ];
+       version = "0.1.0.1";
+       sha256 = "1pamcfv5g6d42ksq10af0l2a6k8y997zx3y4pvf5gcy5hlxr2gwv";
+       libraryHaskellDepends = [
+         base casing containers mtl network text
+       ];
+       testHaskellDepends = [ base containers hspec text ];
        description = "Applicative flag parsing";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        ];
        description = "A new formatting library";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "fmt-for-rio" = callPackage
+    ({ mkDerivation, base, enum-text-rio }:
+     mkDerivation {
+       pname = "fmt-for-rio";
+       version = "1.0.0.0";
+       sha256 = "0hxf1cgch4l5vwnsg4449ing3qi40kpfcwjg4l807sw0b18ccwar";
+       libraryHaskellDepends = [ base enum-text-rio ];
+       description = "Adaptor for getting fmt to work with rio";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "fmt-terminal-colors" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "foundation_0_0_24" = callPackage
+    ({ mkDerivation, base, basement, gauge, ghc-prim }:
+     mkDerivation {
+       pname = "foundation";
+       version = "0.0.24";
+       sha256 = "1yygliyg5dh06n7iyyrvy4iz2328hgb5igjp832wxrfa529pwqdk";
+       libraryHaskellDepends = [ base basement ghc-prim ];
+       testHaskellDepends = [ base basement ];
+       benchmarkHaskellDepends = [ base basement gauge ];
+       description = "Alternative prelude with batteries and no dependencies";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "foundation-edge" = callPackage
     ({ mkDerivation, bytestring, foundation, text }:
      mkDerivation {
···
        pname = "free-vector-spaces";
        version = "0.1.5.0";
        sha256 = "0rf6yhjcd2x4yj2jvyl6yc8x55a2hqhj5mxzg4f24734agh720z1";
-       revision = "1";
-       editedCabalFile = "0b95827ppw0nvhaxg9axkngsij2sj8d6s06amz2vi79jgs7vbfr6";
+       revision = "3";
+       editedCabalFile = "09jy8kj31p6b4pmzry6glq7climw6pmpph23byhijs82a7yl609w";
        libraryHaskellDepends = [
          base lens linear MemoTrie pragmatic-show vector vector-space
        ];
···
     ({ mkDerivation, base, bifunctors, comonad, constraints, containers
      , dependent-sum, deriving-compat, free, hedgehog, kan-extensions
      , mmorph, mtl, natural-transformation, nonempty-containers, pointed
-     , profunctors, recursion-schemes, semigroupoids, tagged, tasty
-     , tasty-hedgehog, these, transformers, trivial-constraint, vinyl
+     , profunctors, semigroupoids, tagged, tasty, tasty-hedgehog, these
+     , transformers, trivial-constraint, vinyl
      }:
      mkDerivation {
        pname = "functor-combinators";
-       version = "0.1.1.0";
-       sha256 = "1x3a2rwqhvcyr298adfc9qband5s5qwh8wfd67cgrq5qx2z4j8xf";
-       revision = "2";
-       editedCabalFile = "09r6bgjlcsjjbwqhfxqbw5dk5sj9lsbfwwsjpdzmi8z8dywgyn2z";
+       version = "0.1.1.1";
+       sha256 = "1bs1xqlndbzi91z9048clmgmgkjyyrkgcmz6s864villy0s9h90c";
        libraryHaskellDepends = [
          base bifunctors comonad constraints containers deriving-compat free
          kan-extensions mmorph mtl natural-transformation
-         nonempty-containers pointed profunctors recursion-schemes
-         semigroupoids tagged these transformers trivial-constraint vinyl
+         nonempty-containers pointed profunctors semigroupoids tagged these
+         transformers trivial-constraint vinyl
        ];
        testHaskellDepends = [
          base bifunctors dependent-sum free hedgehog nonempty-containers
-         semigroupoids tagged tasty tasty-hedgehog transformers
+         semigroupoids tasty tasty-hedgehog transformers
        ];
        description = "Tools for functor combinator-based program design";
        license = stdenv.lib.licenses.bsd3;
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "funspection";
-       version = "0.1.0.0";
-       sha256 = "1bq7gj8kcgz8ccy6skkqbrfkxavkg3s511shm8fd9s8syqwdglr8";
+       version = "1.0.0.0";
+       sha256 = "0jbzvn06d5kfyiav3fjd6k8sk8dy00pwk2g711nrbmlrljbw7f39";
        libraryHaskellDepends = [ base ];
        description = "Type-level function utilities";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "fused-effects_0_4_0_0" = callPackage
+  "fused-effects_0_5_0_0" = callPackage
     ({ mkDerivation, base, criterion, deepseq, doctest, hspec
      , inspection-testing, MonadRandom, QuickCheck, random, transformers
      , unliftio-core
      }:
      mkDerivation {
        pname = "fused-effects";
-       version = "0.4.0.0";
-       sha256 = "1r6yzw0212p5wn9rad2r7pjijnw6jajhypirm4j8h1gz1a393ds8";
+       version = "0.5.0.0";
+       sha256 = "1s1jvxdmwnjyxcx7zhspv1qkfy1dvcj0c92az2njqjibldbvqsa4";
        libraryHaskellDepends = [
          base deepseq MonadRandom random transformers unliftio-core
        ];
···
      }:
      mkDerivation {
        pname = "fused-effects-exceptions";
-       version = "0.1.1.0";
-       sha256 = "0b9rj752ry72n6ln4fj9n6m2d1qfdxp229hzkgxznag0rr3bm5rd";
-       revision = "1";
-       editedCabalFile = "1sg9gvv5lf4z7h70szjcqilhxxjmkiyriz95qyvahplln9p6281l";
+       version = "0.2.0.0";
+       sha256 = "1hgvl48vdrgcb45izmwad40x5jgxiaf3rdhhm5x0gjd9848drmbb";
        libraryHaskellDepends = [
          base fused-effects safe-exceptions unliftio-core
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "fuzzyset_0_1_1" = callPackage
+    ({ mkDerivation, base, base-unicode-symbols, data-default, hspec
+     , ieee754, lens, text, text-metrics, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "fuzzyset";
+       version = "0.1.1";
+       sha256 = "1r23xp3c4f1y0kx0kcg4z83rfxl6swciysb3cy7z6yv35fs8bs4q";
+       libraryHaskellDepends = [
+         base base-unicode-symbols data-default lens text text-metrics
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         base base-unicode-symbols hspec ieee754 lens text
+         unordered-containers
+       ];
+       description = "Fuzzy set for approximate string matching";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "fuzzytime" = callPackage
     ({ mkDerivation, base, cmdargs, directory, old-time, process }:
      mkDerivation {
···
 
   "galois-field" = callPackage
     ({ mkDerivation, base, criterion, integer-gmp, MonadRandom
-     , protolude, tasty, tasty-discover, tasty-quickcheck
-     , wl-pprint-text
+     , protolude, tasty, tasty-quickcheck, wl-pprint-text
      }:
      mkDerivation {
        pname = "galois-field";
-       version = "0.2.0";
-       sha256 = "19q08k5aqnp1vcvlnlw6h4qmlh80dj1rglzckzf7ak78ifcwm1m8";
+       version = "0.3.0";
+       sha256 = "0c4n37rf6kfpyxdmqk4hdgmjc8fvxwynq0izgrhrqinv4z4l97v7";
        libraryHaskellDepends = [
          base integer-gmp MonadRandom protolude tasty-quickcheck
          wl-pprint-text
        ];
        testHaskellDepends = [
-         base integer-gmp MonadRandom protolude tasty tasty-discover
-         tasty-quickcheck wl-pprint-text
+         base integer-gmp MonadRandom protolude tasty tasty-quickcheck
+         wl-pprint-text
        ];
-       testToolDepends = [ tasty-discover ];
        benchmarkHaskellDepends = [
          base criterion integer-gmp MonadRandom protolude tasty-quickcheck
          wl-pprint-text
···
        executableHaskellDepends = [ base cairo containers glib gtk time ];
        description = "Game clock that shows two analog clock faces";
        license = "GPL";
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "gamgee" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
+     , cryptonite, directory, filepath, Hclip, memory
+     , optparse-applicative, polysemy, QuickCheck, quickcheck-instances
+     , relude, safe-exceptions, tasty, tasty-golden, tasty-quickcheck
+     , text, time, unix
+     }:
+     mkDerivation {
+       pname = "gamgee";
+       version = "1.1.0";
+       sha256 = "0ip6y8l2dmw15494d77s771aqmn7awrqnlmbcc7dd2lqwq5s5wgr";
+       revision = "1";
+       editedCabalFile = "1lg04ps7m85x4py844vcc53a3r6ijaqzjrggrwp53iv2ga1m88sr";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base base64-bytestring bytestring cryptonite memory polysemy
+         relude safe-exceptions text time
+       ];
+       executableHaskellDepends = [
+         aeson base directory filepath Hclip optparse-applicative polysemy
+         relude safe-exceptions text time unix
+       ];
+       testHaskellDepends = [
+         aeson base bytestring cryptonite filepath memory polysemy
+         QuickCheck quickcheck-instances relude tasty tasty-golden
+         tasty-quickcheck text time
+       ];
+       description = "Tool for generating TOTP MFA tokens";
+       license = stdenv.lib.licenses.mpl20;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "generics-mrsop_2_0_0" = callPackage
+  "generics-mrsop_2_1_0" = callPackage
     ({ mkDerivation, base, containers, mtl, template-haskell }:
      mkDerivation {
        pname = "generics-mrsop";
-       version = "2.0.0";
-       sha256 = "1cdjh5bjvx8xfglwnm48lfybdz4n8v7v8va2c3zyihzqbxh6akml";
+       version = "2.1.0";
+       sha256 = "1ynzwpwry6fqzjmz3n0iwdp5ra3c402jg1g8sdf7vbpaw9ilyrng";
        libraryHaskellDepends = [ base containers mtl template-haskell ];
        description = "Generic Programming with Mutually Recursive Sums of Products";
        license = stdenv.lib.licenses.mit;
···
 
   "ghc-heap-view" = callPackage
     ({ mkDerivation, base, binary, bytestring, Cabal, containers
-     , deepseq, filepath, ghc, template-haskell, transformers
+     , deepseq, filepath, ghc-heap, template-haskell, transformers
      }:
      mkDerivation {
        pname = "ghc-heap-view";
-       version = "0.5.10";
-       sha256 = "0wb4311k8pyvgmhlxsdr8ss497nlgr8hawkm0fi930s3y4xxak1f";
+       version = "0.6.0";
+       sha256 = "1j2ygig1m7xq1y5gsaaxbgywv382yzlp1nbf3cp98yias0s61vcr";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal filepath ];
        libraryHaskellDepends = [
-         base binary bytestring containers ghc template-haskell transformers
+         base binary bytestring containers ghc-heap template-haskell
+         transformers
        ];
        testHaskellDepends = [ base deepseq ];
        description = "Extract the heap representation of Haskell values and thunks";
···
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "8.8.0.20190424";
-       sha256 = "03f1racabmixc4jk3mn6k6cnhapaplswa8fbb9yajrzj56ag16wm";
+       version = "8.8.0.20190723";
+       sha256 = "161qmm41vayks22vxbji436by1rfbx0x5m2zm4cc11pjcjrd4p63";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "ghc-lib-parser";
-       version = "8.8.0.20190424";
-       sha256 = "12gsh994pr13bsybwlravmi21la66dyw74pk74yfw2pnz682wv10";
+       version = "8.8.0.20190723";
+       sha256 = "0szrv98h2c1db3400cbb7vbhqnwagqncgpllzd9jiw74rq6y8mjq";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
···
        broken = true;
      }) {};
 
+  "ghc-source-gen" = callPackage
+    ({ mkDerivation, base, ghc, ghc-paths, tasty, tasty-hunit }:
+     mkDerivation {
+       pname = "ghc-source-gen";
+       version = "0.1.0.0";
+       sha256 = "0sw62jjbd7h9i96hn0srl9m8p0qip6hnm1am6if7snqdm5b4ki3k";
+       libraryHaskellDepends = [ base ghc ];
+       testHaskellDepends = [ base ghc ghc-paths tasty tasty-hunit ];
+       description = "Constructs Haskell syntax trees for the GHC API";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "ghc-srcspan-plugin" = callPackage
     ({ mkDerivation, array, base, containers, ghc, hpc }:
      mkDerivation {
···
        testHaskellDepends = [ base doctest QuickCheck ];
        description = "GHCi as a Hex Calculator interactive";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "ghci-hexcalc_0_1_1_0" = callPackage
+    ({ mkDerivation, base, binary, doctest, QuickCheck }:
+     mkDerivation {
+       pname = "ghci-hexcalc";
+       version = "0.1.1.0";
+       sha256 = "1kjkx8w1rq1fkzl0ffvp71xjb2q5pmlgnm19g0avim7isrjy87kh";
+       libraryHaskellDepends = [ base binary ];
+       testHaskellDepends = [ base binary doctest QuickCheck ];
+       description = "GHCi as a Hex Calculator interactive";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "ghci-history-parser" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "ghci-websockets" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, foreign-store
+     , text, wai, wai-app-static, warp, websockets
+     }:
+     mkDerivation {
+       pname = "ghci-websockets";
+       version = "0.0.2";
+       sha256 = "0x3hwgsihsr780hxsmjbxhxlw98rv1aws30myh117l7gjmj5lvzg";
+       libraryHaskellDepends = [
+         aeson base bytestring containers foreign-store text wai
+         wai-app-static warp websockets
+       ];
+       description = "A websocket server that survives GHCi reloads";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "ghcid" = callPackage
     ({ mkDerivation, ansi-terminal, base, cmdargs, containers
      , directory, extra, filepath, fsnotify, process, tasty, tasty-hunit
···
        broken = true;
      }) {};
 
+  "ghcprofview" = callPackage
+    ({ mkDerivation, aeson, base, containers, ghc-prof, gi-gtk
+     , haskell-gi-base, regex-tdfa, regex-tdfa-text, scientific, text
+     }:
+     mkDerivation {
+       pname = "ghcprofview";
+       version = "0.1.0.0";
+       sha256 = "103186dik439sdzz1w6dr98s1sfghjxdkp51mh18wrcwdbdb9r3a";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson base containers ghc-prof gi-gtk haskell-gi-base regex-tdfa
+         regex-tdfa-text scientific text
+       ];
+       description = "GHC .prof files viewer";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "ghczdecode" = callPackage
     ({ mkDerivation, base, zenc }:
      mkDerivation {
···
        libraryPkgconfigDepends = [ gtk3 ];
        description = "Gtk bindings";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gtk3;};
 
   "gi-gtk_3_0_31" = callPackage
···
        description = "Gtk bindings";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gtk3;};
 
   "gi-gtk-declarative" = callPackage
-    ({ mkDerivation, base, criterion, gi-gdk, gi-glib, gi-gobject
-     , gi-gtk, haskell-gi, haskell-gi-base, haskell-gi-overloading, mtl
-     , random, text, unordered-containers, vector
+    ({ mkDerivation, async, base, data-default-class, gi-gdk, gi-glib
+     , gi-gobject, gi-gtk, haskell-gi, haskell-gi-base
+     , haskell-gi-overloading, hedgehog, mtl, safe-exceptions, stm, text
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "gi-gtk-declarative";
-       version = "0.4.3";
-       sha256 = "148daz8a6nj6djvsfiy5yk7lfyxhdjl5l34a7d6nn66mikc8538b";
+       version = "0.5.0";
+       sha256 = "0nhacfja1wrz0sa5pbz069sbpyzp8jnlrp078gg9gydwhlmh2k2h";
        libraryHaskellDepends = [
-         base gi-glib gi-gobject gi-gtk haskell-gi haskell-gi-base
-         haskell-gi-overloading mtl text unordered-containers vector
+         base data-default-class gi-glib gi-gobject gi-gtk haskell-gi
+         haskell-gi-base haskell-gi-overloading mtl text
+         unordered-containers vector
        ];
-       benchmarkHaskellDepends = [
-         base criterion gi-gdk gi-glib gi-gtk random text vector
+       testHaskellDepends = [
+         async base gi-gdk gi-glib gi-gobject gi-gtk hedgehog
+         safe-exceptions stm text unordered-containers vector
        ];
        description = "Declarative GTK+ programming in Haskell";
        license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gi-gtk-declarative-app-simple" = callPackage
···
      }:
      mkDerivation {
        pname = "gi-gtk-declarative-app-simple";
-       version = "0.4.2";
-       sha256 = "1ydaxs2isqpy8ld8nlg4plr7ry5xni3g93m9kxdm2klz8xzs3js7";
+       version = "0.5.0";
+       sha256 = "0vl9gqgdbqr4hipr7ka01hyvyz9n8by0ry890w4n2c5w9rghgvva";
        libraryHaskellDepends = [
          async base gi-gdk gi-glib gi-gobject gi-gtk gi-gtk-declarative
          haskell-gi haskell-gi-base haskell-gi-overloading pipes
···
        ];
        description = "Declarative GTK+ programming in Haskell in the style of Pux";
        license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gi-gtk-hs" = callPackage
···
        ];
        description = "A wrapper for gi-gtk, adding a few more idiomatic API parts on top";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gi-gtk-hs_0_3_7_0" = callPackage
···
        description = "A wrapper for gi-gtk, adding a few more idiomatic API parts on top";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gi-gtkosxapplication" = callPackage
···
        pname = "gi-gtkosxapplication";
        version = "2.0.16";
        sha256 = "11wfmvjgl6lmmdanz5jmmvf4289c9jiylxfn006shc4pby7ay6i8";
+       revision = "1";
+       editedCabalFile = "1fixrfjmqqrik38fl90h4f3lh34g6zilscibq9r9x1j8d33qmin4";
        setupHaskellDepends = [ base Cabal haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-gdkpixbuf gi-gobject gi-gtk
···
        doHaddock = false;
        description = "GtkSource bindings";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gtksourceview3;};
 
   "gi-gtksource_3_0_21" = callPackage
···
        description = "GtkSource bindings";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gtksourceview3;};
 
   "gi-handy" = callPackage
···
        libraryPkgconfigDepends = [ vte_291 ];
        description = "Vte bindings";
        license = stdenv.lib.licenses.lgpl21;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {vte_291 = pkgs.vte;};
 
   "gi-vte_2_91_24" = callPackage
···
        description = "Vte bindings";
        license = stdenv.lib.licenses.lgpl21;
        hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {vte_291 = pkgs.vte;};
 
   "gi-webkit" = callPackage
···
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "7.20190708";
-       sha256 = "18s563swrp8mx479995pdhhmn40y3xwlbm1z3w63qsnjqmj7zlij";
+       version = "7.20190730";
+       sha256 = "16mya2dm7q9ggdmwyszri85qnnxf0l71xnn8khnxl5fqrh2zvsjg";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"
          "-f-networkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser"
···
      }:
      mkDerivation {
        pname = "gitlab-haskell";
-       version = "0.1.0.1";
-       sha256 = "1gvhfdlh6x500qms0kfqsyf0c934rm0xw1z1gv8zzb7nssndiann";
+       version = "0.1.0.2";
+       sha256 = "16dj3m038fgxf8w69g8qldnsk2xrk83lkkgdapwv7qz9c9jd0nh1";
        libraryHaskellDepends = [
          aeson base bytestring connection http-conduit http-types text
          transformers unliftio unliftio-core
···
      }) {};
 
   "graphql" = callPackage
-    ({ mkDerivation, attoparsec, base, tasty, tasty-hunit, text }:
+    ({ mkDerivation, aeson, base, hspec, hspec-expectations, megaparsec
+     , raw-strings-qq, text, transformers, unordered-containers
+     }:
      mkDerivation {
        pname = "graphql";
-       version = "0.3";
-       sha256 = "18hb8bwcwx98vrr9nzr8965i4c1y6dh10ilijksbldf10yaiq53z";
+       version = "0.4.0.0";
+       sha256 = "03y8wn0a1zbrsl3i5g5zy5awmlgsncnksskd4gcx8wzfl14120g0";
        enableSeparateDataOutput = true;
-       libraryHaskellDepends = [ attoparsec base text ];
-       testHaskellDepends = [ attoparsec base tasty tasty-hunit text ];
+       libraryHaskellDepends = [
+         aeson base megaparsec text transformers unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson base hspec hspec-expectations megaparsec raw-strings-qq text
+         transformers
+       ];
        description = "Haskell GraphQL implementation";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        libraryHaskellDepends = [ base gi-gdk gi-gtk text transformers ];
        description = "Libary for creating strut windows with gi-gtk";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "gtk-toggle-button-list" = callPackage
···
        broken = true;
      }) {};
 
+  "hapistrano_0_3_9_3" = callPackage
+    ({ mkDerivation, aeson, async, base, directory, filepath
+     , formatting, gitrev, hspec, mtl, optparse-applicative, path
+     , path-io, process, QuickCheck, silently, stm, temporary, time
+     , transformers, typed-process, yaml
+     }:
+     mkDerivation {
+       pname = "hapistrano";
+       version = "0.3.9.3";
+       sha256 = "1kp2gdr0xjzr0qi584lqiqh7hjk8vymz04af2zcgdhbw68brj2cx";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base filepath formatting gitrev mtl path process stm time
+         transformers typed-process
+       ];
+       executableHaskellDepends = [
+         aeson async base formatting gitrev optparse-applicative path
+         path-io stm yaml
+       ];
+       testHaskellDepends = [
+         base directory filepath hspec mtl path path-io process QuickCheck
+         silently temporary
+       ];
+       description = "A deployment library for Haskell applications";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "happindicator" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, glib, gtk
      , gtk2hs-buildtools, libappindicator-gtk2, mtl
···
        broken = true;
      }) {};
 
+  "harg" = callPackage
+    ({ mkDerivation, aeson, barbies, base, bytestring, directory
+     , higgledy, markdown-unlit, optparse-applicative, text, yaml
+     }:
+     mkDerivation {
+       pname = "harg";
+       version = "0.1.0.1";
+       sha256 = "11qkyx9axd8vybkb1kq7vs5v5xf594wgkbpbfpvj0hah7iw9wb95";
+       libraryHaskellDepends = [
+         aeson barbies base bytestring directory higgledy
+         optparse-applicative text yaml
+       ];
+       testHaskellDepends = [
+         aeson barbies base higgledy optparse-applicative
+       ];
+       testToolDepends = [ markdown-unlit ];
+       description = "Haskell program configuration from multiple sources";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "hark" = callPackage
     ({ mkDerivation, base, bytestring, directory, filepath, haskell98
      , mtl, old-locale, old-time, regex-pcre
···
        pname = "hasbolt";
        version = "0.1.3.3";
        sha256 = "1l1p9iz9k8i1car5cd6cfd2bpidkrfbr2354hxvg8gpnw1i5jsbb";
+       revision = "1";
+       editedCabalFile = "0v4ksld4qs1ll5a5c6x5kvrcb584yskhbda7zv9r9lrqvcsjwg5i";
        libraryHaskellDepends = [
          base binary bytestring connection containers data-binary-ieee754
          data-default network text transformers
···
      }:
      mkDerivation {
        pname = "hasbolt-extras";
-       version = "0.0.0.18";
-       sha256 = "11ij6xrxf28sv8b464dqax9834k0r6q99hdyfsg030aw2i1rqygy";
+       version = "0.0.0.19";
+       sha256 = "11g6rlgyxi57bvmr862ly7yfwiiph1kckr056b5khz8v8k6fhhpv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        doHaddock = false;
        description = "Cabal package script generator for Travis-CI";
        license = stdenv.lib.licenses.bsd3;
+       maintainers = with stdenv.lib.maintainers; [ peti ];
      }) {};
 
   "haskell-cnc" = callPackage
···
      }:
      mkDerivation {
        pname = "haskell-conll";
-       version = "0.1.0.1";
-       sha256 = "09lgj70lk2xh75rq4gdmfacmb465r0xn03v8cnk82bx52c7jwiga";
+       version = "0.1.0.2";
+       sha256 = "05w90jlidxr55r5j1hihfhdcwjkzw85xipwxdd3i6kmskin2pv1v";
        libraryHaskellDepends = [
          base containers lens pretty-show protolude split text
        ];
        description = "Core Types for NLP";
-       license = stdenv.lib.licenses.bsd3;
+       license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "haskeme";
-       version = "0.1.0.3";
-       sha256 = "14hrimm52v5hlgkdkqwijxrfnzj8x46bg3kh9nw1vlflf97053wf";
+       version = "0.1.0.4";
+       sha256 = "0lis0ni0l52x691adm2da7mzjam4g414gc0d0i9f6i050ra02g3j";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
···
      , haskoin-node, hspec, hspec-discover, http-types, monad-logger
      , mtl, network, nqe, optparse-applicative, random, resourcet
      , rocksdb-haskell, rocksdb-query, scotty, string-conversions, text
-     , time, transformers, unliftio, unordered-containers, uuid
+     , time, transformers, unliftio, unordered-containers, wai
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.16.5";
-       sha256 = "111gip8l2c9m85viaz02rlxhdb6svwx0jyhrkzcqjgz4j3y0n4lj";
+       version = "0.16.6";
+       sha256 = "03214p8xqf062grgpkbfchrm4awm0zrq41j77z8s31iin9d0qzp9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          hashable haskoin-core haskoin-node http-types monad-logger mtl
          network nqe random resourcet rocksdb-haskell rocksdb-query scotty
          string-conversions text time transformers unliftio
-         unordered-containers uuid
+         unordered-containers wai
        ];
        executableHaskellDepends = [
          aeson base bytestring cereal conduit containers data-default
          filepath hashable haskoin-core haskoin-node http-types monad-logger
          mtl network nqe optparse-applicative random resourcet
          rocksdb-haskell rocksdb-query scotty string-conversions text time
-         transformers unliftio unordered-containers uuid
+         transformers unliftio unordered-containers wai
        ];
        testHaskellDepends = [
          aeson base bytestring cereal conduit containers data-default
          hashable haskoin-core haskoin-node hspec http-types monad-logger
          mtl network nqe random resourcet rocksdb-haskell rocksdb-query
          scotty string-conversions text time transformers unliftio
-         unordered-containers uuid
+         unordered-containers wai
        ];
        testToolDepends = [ hspec-discover ];
        description = "Storage and index for Bitcoin and Bitcoin Cash";
···
      }:
      mkDerivation {
        pname = "haven";
-       version = "0.2.0.1";
-       sha256 = "15q9cgfifz87ns730agv2vzc8rp5lqggiclc91khpckm2qppk6yd";
+       version = "0.2.0.2";
+       sha256 = "0n92h5gjy6ax0c5f2k80j21ymf741vzhsm1kdav86hphhxdlw8ng";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hedgehog-classes";
-       version = "0.2.1";
-       sha256 = "1hkkbmsn397a73aqaasi2c076nx9g8s8vsdp6wdqq33a96q1b0mq";
+       version = "0.2.2";
+       sha256 = "072w697nc7dv9yi700g5ap4h49ichpw1srzkq07sz637022l19wl";
        libraryHaskellDepends = [
          aeson base binary containers hedgehog pretty-show semirings
          silently transformers wl-pprint-annotated
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "hedis_0_12_5" = callPackage
+  "hedis_0_12_6" = callPackage
     ({ mkDerivation, async, base, bytestring, bytestring-lexing
      , deepseq, doctest, errors, HTTP, HUnit, mtl, network, network-uri
      , resource-pool, scanner, stm, test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "hedis";
-       version = "0.12.5";
-       sha256 = "1alabz8j9lmd2ydm34hndqcyvihnfyvl7cgda6ycsch5sbffmjlp";
+       version = "0.12.6";
+       sha256 = "1lx7lwh282ijp63yfy6ybb6zc5zil09abnrsbm052ghdlnz3sfk1";
        libraryHaskellDepends = [
          async base bytestring bytestring-lexing deepseq errors HTTP mtl
          network network-uri resource-pool scanner stm text time tls
···
        pname = "hi-file-parser";
        version = "0.1.0.0";
        sha256 = "09gs26z0jvkkhb1r43gj27pq0k5fc4i6fpr59g397vz4sm86gb2l";
-       revision = "1";
-       editedCabalFile = "1hylfzkd42mqap2ydh4wq96vwbblyp26zb8wwyn63yl72swbww23";
+       revision = "2";
+       editedCabalFile = "1bm98h0v4wf9vmdng15c2r48yz06118jxlprsnk0z3jw0d95ij9z";
        libraryHaskellDepends = [ base binary bytestring rio vector ];
        testHaskellDepends = [ base binary bytestring hspec rio vector ];
        description = "Parser for GHC's hi files";
···
      }:
      mkDerivation {
        pname = "hierarchical-spectral-clustering";
-       version = "0.4.0.0";
-       sha256 = "1mw546dvyzrhcw7a61zb0anfgxk3s5r3bjrj7iry36shh1ancs1s";
+       version = "0.4.1.1";
+       sha256 = "0wi1yw0mhszalixay7sd1n7i8xjmb3m6v7h3kn09ih5vn3bxj26f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hills";
        version = "0.1.2.6";
        sha256 = "0ggdppg7mbq3ljrb4hvracdv81m9jqnsrl6iqy56sba118k7m0jh";
-       revision = "2";
-       editedCabalFile = "11f4mmhxivxkdcn4wdcz1hszfyi3hdggls22x2q0m3jxq3lw0izg";
+       revision = "3";
+       editedCabalFile = "10l4hx0j8il66h3m9flhwsqm9v52qmpj4cyjih4c6cnng6vjsfnj";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }) {};
 
   "hit-on" = callPackage
-    ({ mkDerivation, ansi-terminal, base, base-noprelude, github
-     , gitrev, optparse-applicative, relude, shellmet, text, vector
+    ({ mkDerivation, ansi-terminal, base, base-noprelude, directory
+     , github, gitrev, hspec, optparse-applicative, process, relude
+     , shellmet, text, vector
      }:
      mkDerivation {
        pname = "hit-on";
-       version = "0.0.0";
-       sha256 = "14npvwxh33cn8z2klp7liij41r9pyr00rs4g28yva2zry75bf98r";
-       revision = "1";
-       editedCabalFile = "1fwvm0fz2agqziaspxlxxmdv44xrv65pf601i0938wkx4452v8fz";
+       version = "0.1.0.0";
+       sha256 = "13pxn9xqyfd5n53bl57bk0wc8qlnl5dsh1xq5y49arsnk2g86ir5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ansi-terminal base-noprelude github gitrev optparse-applicative
-         relude shellmet text vector
+         ansi-terminal base-noprelude directory github gitrev
+         optparse-applicative process relude shellmet text vector
        ];
        executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base github hspec text ];
        description = "Haskell Git Helper Tool";
        license = stdenv.lib.licenses.mpl20;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        pname = "hjsonschema";
        version = "1.9.0";
        sha256 = "051i5y557g82hd5zcn63f65jyxk07d9wnvfmwdps391zxza8ifki";
-       revision = "1";
-       editedCabalFile = "1kxn0smmcmzysvi1bw9v0j6j68fk4s36nqyqmvbkl61pgm6bs803";
+       revision = "2";
+       editedCabalFile = "0110dyc8lbd8x0cbmxgwwbvzckxkfj84krd5p51p0jaixvrrl53r";
        libraryHaskellDepends = [
          aeson base bytestring containers file-embed filepath hashable
          hjsonpointer http-client http-client-tls http-types pcre-heavy
···
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
+  "hjugement-cli" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring
+     , containers, cryptonite, deepseq, directory, filepath, ghc-prim
+     , hjugement, hjugement-protocol, lens-family-core, memory, pipes
+     , pipes-aeson, pipes-bytestring, pipes-group, pipes-parse
+     , pipes-safe, pipes-text, random, reflection, symantic-cli
+     , symantic-document, terminal-size, text, time, transformers, unix
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "hjugement-cli";
+       version = "0.0.0.20190721";
+       sha256 = "1fgl9yjjmwd8y2hcmva0fh3d6qwvj8papdm0v50s85b9s8cwn6ll";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson base base64-bytestring binary bytestring containers
+         cryptonite deepseq directory filepath ghc-prim hjugement
+         hjugement-protocol lens-family-core memory pipes pipes-aeson
+         pipes-bytestring pipes-group pipes-parse pipes-safe pipes-text
+         random reflection symantic-cli symantic-document terminal-size text
+         time transformers unix unordered-containers
+       ];
+       description = "Majority Judgment and Helios-C command line tool";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "hjugement-protocol" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring
      , containers, criterion, cryptonite, deepseq, memory, QuickCheck
···
      }:
      mkDerivation {
        pname = "hjugement-protocol";
-       version = "0.0.1.20190623";
-       sha256 = "0rqsggij0vx9hh7wl8nzmycb55ilcm0j6dp33x94jycpyvqnc4ym";
+       version = "0.0.4.20190711";
+       sha256 = "0r4g8n1a8c0azdk307mq1q2dv1h4xf251fjrmldcws7b0vrla5ri";
        libraryHaskellDepends = [
          aeson base base64-bytestring binary bytestring containers
          cryptonite deepseq memory random reflection text transformers
···
        pname = "hledger-iadd";
        version = "1.3.9";
        sha256 = "07g48w4099m4vm7z5hrg9zzd2v2yhy7kcv40902njz6v8cklgdgq";
+       revision = "1";
+       editedCabalFile = "18qjkl79gwmdgk6vl8cg3m94wm0qw30kxn4lvlnj9n6gnv2p0b3k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hlint";
-       version = "2.2";
-       sha256 = "0921s4cnpjnxmsp8x5dhjs8qiv6mlw98nngwsq6ad5qrj1wn72lx";
+       version = "2.2.2";
+       sha256 = "1v10xcz4vdzk1a3gjlvqbdckldax2643sg7s3xkm3dnlj5hg05yp";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "hoogle";
-       version = "5.0.17.9";
-       sha256 = "0s4p82issy3jlc0yz153r7i38ny1ygchf294hgms6jr1q467w86z";
+       version = "5.0.17.10";
+       sha256 = "12s3n3l6lf2vwmh4jbxnra694fpnzjgd8c236pnan0jdcb6x82vl";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "horname";
-       version = "0.1.3.0";
-       sha256 = "067jnyqk4lwrr23hvc30rqjmd400n9vd8wvj9bq67w47paqcz9p9";
-       revision = "1";
-       editedCabalFile = "10cgcxvpl0s4hs2r5g34kcdiy676azz751j3w5703m54mpz9irwl";
+       version = "0.2.0.0";
+       sha256 = "1qcvgjwasrgi760sv5rxl5klincgw34xczd3mqz32id183s57164";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "hs-rqlite" = callPackage
+    ({ mkDerivation, aeson, base, bifunctors, bytestring, containers
+     , HTTP, scientific, text, unordered-containers
+     }:
+     mkDerivation {
+       pname = "hs-rqlite";
+       version = "0.1.0.0";
+       sha256 = "04q9vnwil3f30972pljs613wq1kb71w61jivdyxxy9i14grfcxsq";
+       libraryHaskellDepends = [
+         aeson base bifunctors bytestring containers HTTP scientific text
+         unordered-containers
+       ];
+       description = "A Haskell client for RQlite";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hs-rs-notify" = callPackage
     ({ mkDerivation, base, filepath, notifier, process, protolude, text
      , unix
···
        broken = true;
      }) {};
 
-  "hsdev_0_3_3_1" = callPackage
+  "hsdev_0_3_3_2" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, async, attoparsec
      , base, bytestring, Cabal, containers, cpphs, data-default, deepseq
      , direct-sqlite, directory, exceptions, filepath, fsnotify, ghc
···
      }:
      mkDerivation {
        pname = "hsdev";
-       version = "0.3.3.1";
-       sha256 = "09i1m3xkvjzq69mpzf73g3jxf3g5md8lfrxjwza6ns8ii9m4xcqh";
+       version = "0.3.3.2";
+       sha256 = "1qx5ppj1l871pm9qhqwd4297p3cp0v0fv64fkw4cdbpjza798x1i";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hspec-megaparsec_2_0_1" = callPackage
+    ({ mkDerivation, base, containers, hspec, hspec-expectations
+     , megaparsec
+     }:
+     mkDerivation {
+       pname = "hspec-megaparsec";
+       version = "2.0.1";
+       sha256 = "0w8nn2rh01lkiwsiyqh3gviklhfmy0245rakj94dmliyljw8skfg";
+       libraryHaskellDepends = [
+         base containers hspec-expectations megaparsec
+       ];
+       testHaskellDepends = [ base hspec hspec-expectations megaparsec ];
+       description = "Utility functions for testing Megaparsec parsers with Hspec";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hspec-meta" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, call-stack, clock
      , deepseq, directory, filepath, hspec-expectations, HUnit
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "htdp-image" = callPackage
+    ({ mkDerivation, AC-Angle, base, gloss, HUnit, test-framework
+     , test-framework-hunit
+     }:
+     mkDerivation {
+       pname = "htdp-image";
+       version = "1.1.0.0";
+       sha256 = "17123nqkg8yk0pssmshdza0ipc42rx818q9gidig1d1camiyrfl4";
+       libraryHaskellDepends = [ AC-Angle base gloss ];
+       testHaskellDepends = [
+         base gloss HUnit test-framework test-framework-hunit
+       ];
+       description = "Beginner friendly graphics library";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "htestu" = callPackage
     ({ mkDerivation, base, gcc, random }:
      mkDerivation {
···
        pname = "http-download";
        version = "0.1.0.0";
        sha256 = "0wip7l6cls734ag306s5l0683qqh273b3lk5ibig66racmysjqyb";
-       revision = "3";
-       editedCabalFile = "147fjxz1y3rqwnrhvrhgg2d93fl6pbwkhc2fbzriwn7kyan8z06l";
+       revision = "4";
+       editedCabalFile = "1s20zjh52whs6hfhr90zyyy7g78zv1pw9hry1nwlzdv4hg97cbdh";
        libraryHaskellDepends = [
          base base64-bytestring bytestring conduit conduit-extra cryptonite
          cryptonite-conduit directory exceptions filepath http-client
···
      }:
      mkDerivation {
        pname = "hw-kafka-avro";
-       version = "4.0.0";
-       sha256 = "0khqvd1l44bx4mnrv7hbvr0qbak6n17l4qqk3lwga21qnchnlgak";
+       version = "4.0.1";
+       sha256 = "1x0mq3sn05iwrn444kzyl66056xm8203hq0ajx9f8r85faq3v1ir";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "hw-prim_0_6_2_29" = callPackage
+  "hw-prim_0_6_2_31" = callPackage
     ({ mkDerivation, base, bytestring, criterion, directory, exceptions
      , ghc-prim, hedgehog, hspec, hspec-discover, hw-hspec-hedgehog
-     , mmap, QuickCheck, semigroups, transformers, vector
+     , mmap, QuickCheck, semigroups, transformers, unliftio-core, vector
      }:
      mkDerivation {
        pname = "hw-prim";
-       version = "0.6.2.29";
-       sha256 = "1pbcmi3ysaidhb5jlllmdwdkh7gbky234qxf5j2r5lk3n0n6zzp1";
+       version = "0.6.2.31";
+       sha256 = "00xfakvwnj3zys2ilpc9w9z5qzw1ng3cc65jfa1860z6yr7xdp59";
        libraryHaskellDepends = [
-         base bytestring ghc-prim mmap semigroups transformers vector
+         base bytestring ghc-prim mmap semigroups transformers unliftio-core
+         vector
        ];
        testHaskellDepends = [
          base bytestring directory exceptions hedgehog hspec
···
      }:
      mkDerivation {
        pname = "hw-uri";
-       version = "0.0.2.0";
-       sha256 = "0z2y9ykg6q3p7qgm7s66sg5cw3pf2cbjlqk8xf6l7qgpa7br1z2b";
+       version = "0.1.1.0";
+       sha256 = "1f96632k6pcaxhy2nrm13s9kdb0dz3vsav6hzf94wlv7zdlncn8x";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-s3 antiope-core antiope-s3
          base bytestring directory exceptions filepath http-client
···
   "mega-sdist" = callPackage
   "mega-sdist" = callPackage
   "mega-sdist" = callPackage
-  "mega-sdist" = callPackage
-  "mega-sdist" = callPackage
-  "mega-sdist" = callPackage
-  "mega-sdist" = callPackage
+     , network, optparse-applicative, parser-combinators, pretty
+     , process, regex-tdfa, safe, split, tagged, tasty, tasty-golden
+     , tasty-rerun, terminal-size, text, time, transformers, uniplate
+     , unix, unordered-containers, utf8-string, vector
+     , vector-binary-instances, zip-archive
      }:
      mkDerivation {
   "mega-sdist" = callPackage
-       version = "1.3.1";
-  "mega-sdist" = callPackage
+       version = "1.3.2";
+       sha256 = "0wychzkg0yghd2pp8fqz78vp1ayzks191knfpl7mhh8igsmb6bc7";
   "mega-sdist" = callPackage
        isLibrary = true;
        isExecutable = true;
···
   "mega-sdist" = callPackage
   "mega-sdist" = callPackage
   "mega-sdist" = callPackage
-  "mega-sdist" = callPackage
-  "mega-sdist" = callPackage
+         optparse-applicative parser-combinators pretty process regex-tdfa
+         safe split terminal-size text time transformers uniplate unix
   "mega-sdist" = callPackage
          zip-archive
        ];
···
        ];
   "mega-sdist" = callPackage
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gmp;};
 
   "mega-sdist" = callPackage
···
        license = "GPL";
      }) {};
 
+  "iexcloud" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, http-conduit
+     , HUnit, semigroups, stocks, unordered-containers
+     }:
+     mkDerivation {
+       pname = "iexcloud";
+       version = "0.0.0.1";
+       sha256 = "15qn3h1bz75bykcnyra6gg4d33gmr6ywc485hk2gmi4k6hbl6amf";
+       libraryHaskellDepends = [
+         aeson base bytestring containers http-conduit semigroups
+         unordered-containers
+       ];
+       testHaskellDepends = [ base bytestring HUnit stocks ];
+       description = "Library for the IEX Trading API";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "mega-sdist" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "mega-sdist" = callPackage
+  "influxdb_1_7_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
   "mega-sdist" = callPackage
-  "mega-sdist" = callPackage
-  "mega-sdist" = callPackage
+     , http-types, lens, network, optional-args, raw-strings-qq
+     , scientific, tagged, tasty, tasty-hunit, template-haskell, text
+     , time, unordered-containers, vector
      }:
      mkDerivation {
   "mega-sdist" = callPackage
-       version = "1.7.0";
-  "mega-sdist" = callPackage
+       version = "1.7.1";
+       sha256 = "1nny63rd9bw7ijg9l09cd467whfaa1n3ph8dqdy7bp6kcbvdwnzn";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
   "mega-sdist" = callPackage
          unordered-containers vector
        ];
-  "mega-sdist" = callPackage
+       testHaskellDepends = [
+         base containers doctest raw-strings-qq tasty tasty-hunit
+         template-haskell time
+       ];
   "mega-sdist" = callPackage
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
   "mega-sdist" = callPackage
        version = "1.0.3";
   "mega-sdist" = callPackage
+       revision = "1";
+       editedCabalFile = "1z6z63jr42jn073fd9ns7jcrw7n5lwx076q4b5rgzak7q1ixw2i8";
   "mega-sdist" = callPackage
        testHaskellDepends = [
   "mega-sdist" = callPackage
···
   "mega-sdist" = callPackage
        version = "0.1.2";
   "mega-sdist" = callPackage
-       revision = "1";
-  "mega-sdist" = callPackage
+       revision = "2";
+       editedCabalFile = "0j6zmj0dlhiq4qjrbjbvdsmky1l4z1qwqikixk1b9dpa05n01ykf";
        libraryHaskellDepends = [
   "mega-sdist" = callPackage
   "mega-sdist" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "mega-sdist" = callPackage
+  "ip_1_5_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, criterion
   "mega-sdist" = callPackage
   "mega-sdist" = callPackage
···
      }:
      mkDerivation {
   "mega-sdist" = callPackage
-       version = "1.5.0";
-  "mega-sdist" = callPackage
-       revision = "1";
-  "mega-sdist" = callPackage
+       version = "1.5.1";
+       sha256 = "1crnn76vxhqq13556nc0537bh8xi5jzklyp24dqqfamxmfbwkzll";
        libraryHaskellDepends = [
   "mega-sdist" = callPackage
   "mega-sdist" = callPackage
···
   "mega-sdist" = callPackage
      mkDerivation {
   "mega-sdist" = callPackage
-  "mega-sdist" = callPackage
-  "mega-sdist" = callPackage
+       version = "8.1.0";
+       sha256 = "07n5xnspl318hrmff4gr274zpgszgviilwhjd7vdrhm1sq9sdir8";
   "mega-sdist" = callPackage
   "mega-sdist" = callPackage
-       license = stdenv.lib.licenses.lgpl3;
+       license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
   "mega-sdist" = callPackage
      mkDerivation {
   "mega-sdist" = callPackage
-       version = "2.0.0";
-  "mega-sdist" = callPackage
+       version = "2.1.0";
+       sha256 = "0qcmqy8p13hg9aih8m9w7qpbr6zcbvgc9y6bzh2cqm2sbx7ksvqm";
   "mega-sdist" = callPackage
   "mega-sdist" = callPackage
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "irc-client_1_1_1_0" = callPackage
+  "mega-sdist" = callPackage
+  "mega-sdist" = callPackage
+  "mega-sdist" = callPackage
+  "mega-sdist" = callPackage
+     }:
+     mkDerivation {
+  "mega-sdist" = callPackage
+       version = "1.1.1.0";
+       sha256 = "1f2lqg37ig3f23066c4179vcym6p3ylmxsywqhmb0n078kix6kfb";
+       libraryHaskellDepends = [
+  "mega-sdist" = callPackage
+  "mega-sdist" = callPackage
+  "mega-sdist" = callPackage
+  "mega-sdist" = callPackage
+       ];
+  "mega-sdist" = callPackage
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "mega-sdist" = callPackage
     ({ mkDerivation, base, text }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "jaeger-flamegraph";
-       version = "1.3.0";
-       sha256 = "03j5hjrhyhmc6qjp7v4j0mr2y0fpk0zds6v55as24par508w72ka";
-       revision = "2";
-       editedCabalFile = "0p2pcfyrcbqh0rnmhhp5hbwixvlml62iz0d48z7dd6cwfdzlkfrr";
+       version = "1.3.2";
+       sha256 = "1m7vs4zi1cm5xj3wn8zr44rdx1l99ra59xwr64y9bdrs1raga7k3";
+       revision = "1";
+       editedCabalFile = "003h3aqdkpvpqqyv7ypv3shvfiqcwq7cfihqv38bp2iq5vin938q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ aeson base containers QuickCheck text ];
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
+  "jose_0_8_1_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
+     , bytestring, concise, containers, cryptonite, hspec, lens, memory
+     , monad-time, mtl, network-uri, QuickCheck, quickcheck-instances
+     , safe, semigroups, tasty, tasty-hspec, tasty-quickcheck
+     , template-haskell, text, time, unordered-containers, vector, x509
+     }:
+     mkDerivation {
+       pname = "jose";
+       version = "0.8.1.0";
+       sha256 = "02xg8axy6whbkn0mzg1gjy6b1mhxlmsh1x7vjk1fiawvg9nwzrkl";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base base64-bytestring bytestring concise
+         containers cryptonite lens memory monad-time mtl network-uri
+         QuickCheck quickcheck-instances safe semigroups template-haskell
+         text time unordered-containers vector x509
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base base64-bytestring bytestring concise
+         containers cryptonite hspec lens memory monad-time mtl network-uri
+         QuickCheck quickcheck-instances safe semigroups tasty tasty-hspec
+         tasty-quickcheck template-haskell text time unordered-containers
+         vector x509
+       ];
+       description = "Javascript Object Signing and Encryption and JSON Web Token library";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "jose-jwt" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
      , containers, criterion, cryptonite, doctest, either, hspec, HUnit
···
      }) {};
 
   "jsaddle-dom" = callPackage
-    ({ mkDerivation, base, base-compat, exceptions, jsaddle, lens, text
-     , transformers
+    ({ mkDerivation, base, base-compat, Cabal, exceptions, jsaddle
+     , lens, text, transformers
      }:
      mkDerivation {
        pname = "jsaddle-dom";
-       version = "0.9.3.1";
-       sha256 = "0ifbddp4vjpbl89bwczfp7ivnhfayg8317l8qk6h84p9vd1km44z";
+       version = "0.9.3.2";
+       sha256 = "1qc135w1y4f2mbky36dmb0ggcbwkv1vnmszw5lkhkxhkcag2sf07";
+       setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          base base-compat exceptions jsaddle lens text transformers
        ];
···
      }:
      mkDerivation {
        pname = "json-api";
-       version = "0.1.1.2";
-       sha256 = "092x0zldcz6dsvvsxs2zr4cp4mbwjsrdpcassrl5i715x9rb5fmm";
+       version = "0.1.4.0";
+       sha256 = "1xswmpkwr1f49kf4hmp9014lwv4lcnyjj161ylfh5ihjfr30w0yb";
        libraryHaskellDepends = [
          aeson base containers data-default lens lens-aeson text
          unordered-containers url
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "json5hs" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, mtl, pretty
+     , syb, text
+     }:
+     mkDerivation {
+       pname = "json5hs";
+       version = "0.1.2.2";
+       sha256 = "19r1ripvalrhvlqdk0pvm18b4a8sibdwlc60i2yj7da10rdx5cv1";
+       libraryHaskellDepends = [
+         array base bytestring containers mtl pretty syb text
+       ];
+       description = "Serialising to and from JSON5";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "jsonextfilter" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
      , monads-tf, optparse-applicative, process, scientific, string-qq
···
 
   "jsonpath" = callPackage
     ({ mkDerivation, aeson, aeson-casing, attoparsec, base, bytestring
-     , file-embed, hspec, hspec-attoparsec, text, unordered-containers
-     , vector
+     , file-embed, hspec, hspec-attoparsec, hspec-discover, text
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "jsonpath";
-       version = "0.1.0.0";
-       sha256 = "0lr0sw30siaycw92b1xbnlrjn1pb7y8l9dflrjzr5d9k43lnrz42";
+       version = "0.1.0.1";
+       sha256 = "0wp5516g33spb9ilphjkzamr88xl64fb6y9zjfci1kac5vkl4qqk";
+       revision = "2";
+       editedCabalFile = "04jw3ayvcabsfcqazksnn0rg0i1326d0gjdx1zl8rk955g2qlwam";
        libraryHaskellDepends = [
          aeson attoparsec base text unordered-containers vector
        ];
···
          aeson aeson-casing attoparsec base bytestring file-embed hspec
          hspec-attoparsec text unordered-containers vector
        ];
+       testToolDepends = [ hspec-discover ];
        description = "Library to parse and execute JSONPath";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "katip_0_8_2_0" = callPackage
+  "katip_0_8_3_0" = callPackage
     ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
      , bytestring, containers, criterion, deepseq, directory, either
      , filepath, hostname, microlens, microlens-th, monad-control, mtl
···
      }:
      mkDerivation {
        pname = "katip";
-       version = "0.8.2.0";
-       sha256 = "064i2dbl52i2z7lyvk01ayvf6dzzn20bac3fwh0dlvr5bn49wran";
+       version = "0.8.3.0";
+       sha256 = "0wpqchpgrp7awrf7hirg0768g8nnqrydnwcw8xgxw6w47zcb71d0";
        libraryHaskellDepends = [
          aeson async auto-update base bytestring containers either hostname
          microlens microlens-th monad-control mtl old-locale resourcet
···
      }:
      mkDerivation {
        pname = "keera-hails-reactive-gtk";
-       version = "0.3";
-       sha256 = "0b3j9h0d4sw1hhgihnlqpiyc9bwfk5qd6jl64jij3q3rjy97wr3v";
+       version = "0.5";
+       sha256 = "014d9hr2321gs6ska8ykrgh59k92c6kxf0a3gqvrfj3rck28izb9";
        libraryHaskellDepends = [
          base bytestring cairo glib gtk gtk-helpers
          keera-hails-reactivevalues mtl transformers
···
      }) {};
 
   "keera-hails-reactive-network" = callPackage
-    ({ mkDerivation, base, keera-hails-reactivevalues, network }:
+    ({ mkDerivation, base, bytestring, keera-hails-reactivevalues
+     , network, network-bsd
+     }:
      mkDerivation {
        pname = "keera-hails-reactive-network";
-       version = "0.0.3.3";
-       sha256 = "1379djvy5nn6k67ds7mk9jjh03zd6sj0v8sf5agmk3pf5cyp0xa3";
+       version = "0.1";
+       sha256 = "1d1r9p5ray60yfrxs89byc7rmdsm340k2b8klv25k0wh2fvrx2yw";
        libraryHaskellDepends = [
-         base keera-hails-reactivevalues network
+         base bytestring keera-hails-reactivevalues network network-bsd
        ];
        description = "Haskell on Rails - Sockets as Reactive Values";
        license = stdenv.lib.licenses.bsd3;
···
 
   "korea-holidays" = callPackage
     ({ mkDerivation, aeson, base, hspec, monad-extras, split
-     , template-haskell, yaml
+     , template-haskell, time, yaml
      }:
      mkDerivation {
        pname = "korea-holidays";
-       version = "0.1.0.3";
-       sha256 = "0v240dkvqy1jhkq1mzhyaiyg62m8lbbm79bc2g31jy9b7r1h93i2";
+       version = "0.1.0.4";
+       sha256 = "11yiip6nv84k8q4n37w9kn1w57vizlcggszh0pnrkkx36xwwk9ll";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         aeson base monad-extras split template-haskell yaml
+         aeson base monad-extras split template-haskell time yaml
        ];
        testHaskellDepends = [
-         aeson base hspec monad-extras split template-haskell yaml
+         aeson base hspec monad-extras split template-haskell time yaml
        ];
        description = "Korea Holidays";
        license = stdenv.lib.licenses.mit;
···
        broken = true;
      }) {egl = null; inherit (pkgs) glew;};
 
+  "kubernetes-client" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, connection, containers
+     , data-default-class, hspec, http-client, http-client-tls
+     , kubernetes-client-core, microlens, mtl, pem, safe-exceptions
+     , streaming-bytestring, text, tls, x509, x509-store, x509-system
+     , x509-validation, yaml
+     }:
+     mkDerivation {
+       pname = "kubernetes-client";
+       version = "0.1.0.1";
+       sha256 = "0fzilm4k7cq3k6vlx01c5gzg4lnrgpfdldbiml4rbiv42f13pr7j";
+       libraryHaskellDepends = [
+         aeson base bytestring connection containers data-default-class
+         http-client http-client-tls kubernetes-client-core microlens mtl
+         pem safe-exceptions streaming-bytestring text tls x509 x509-store
+         x509-system x509-validation
+       ];
+       testHaskellDepends = [
+         aeson base bytestring connection containers data-default-class
+         hspec http-client http-client-tls kubernetes-client-core microlens
+         mtl pem safe-exceptions streaming-bytestring text tls x509
+         x509-store x509-system x509-validation yaml
+       ];
+       description = "Client library for Kubernetes";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "kubernetes-client-core" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
+     , case-insensitive, containers, deepseq, exceptions, hspec
+     , http-api-data, http-client, http-client-tls, http-media
+     , http-types, iso8601-time, katip, microlens, mtl, network
+     , QuickCheck, random, safe-exceptions, semigroups, text, time
+     , transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "kubernetes-client-core";
+       version = "0.1.0.1";
+       sha256 = "08sxsc9a9vdsqp71zxnc309cng75k3c57mcmmryhpwwyscvgfnsk";
+       revision = "1";
+       editedCabalFile = "0qzh7zq36q57yfccna1izi1gz9fpki9ngnl8dgf3m6halrxwqlc7";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring bytestring case-insensitive containers
+         deepseq exceptions http-api-data http-client http-client-tls
+         http-media http-types iso8601-time katip microlens mtl network
+         random safe-exceptions text time transformers unordered-containers
+         vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers hspec iso8601-time mtl QuickCheck
+         semigroups text time transformers unordered-containers vector
+       ];
+       description = "Auto-generated kubernetes-client-core API Client";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "kure" = callPackage
     ({ mkDerivation, base, dlist, transformers }:
      mkDerivation {
···
        ];
        description = "Declarative command-line parser using type-driven pattern matching";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "lambda-placeholders" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "lattices_2" = callPackage
+  "lattices_2_0_1" = callPackage
     ({ mkDerivation, base, base-compat, containers, deepseq, hashable
      , integer-logarithms, QuickCheck, quickcheck-instances
      , semigroupoids, tagged, tasty, tasty-quickcheck, transformers
···
      }:
      mkDerivation {
        pname = "lattices";
-       version = "2";
-       sha256 = "050c66rrzh5p204jyqmysyhm419f8pasi0mlbwv3n167y0fnr8xq";
-       revision = "1";
-       editedCabalFile = "08m46liplbh1xxnpsq0wnjabmyj625vbnnsyypd52jlhzclfhqz1";
+       version = "2.0.1";
+       sha256 = "0c7n7fh89llg8ijylwc14ikqrg077vcqcgph5h9nar6i5dyaprfy";
        libraryHaskellDepends = [
          base base-compat containers deepseq hashable integer-logarithms
          QuickCheck semigroupoids tagged transformers universe-base
···
        pname = "lazy-hash";
        version = "0.1.0.0";
        sha256 = "1xa2c8gxk5l4njbs58zpq2ybdvjd4y214p71nfmfrzw0arwz49pa";
-       revision = "1";
-       editedCabalFile = "07sn3q7q29zkxpillprx2d05pybjpvpglz8s7jq07akdhwmwx9mk";
+       revision = "2";
+       editedCabalFile = "0j46blbddl9y4chccyns7cixbxb0a4pkmdkbd5z09510ddz3jqm3";
        libraryHaskellDepends = [
          base constrained-categories hashable haskell-src-meta tagged
          template-haskell vector-space
···
        pname = "lazy-hash-cache";
        version = "0.1.0.0";
        sha256 = "1bdq2fbxpmlva1qbxbiznnjmz7yv7qzcr8wdgds0rdzwhjn97mp4";
+       revision = "1";
+       editedCabalFile = "1m42wsj93vpb6v1dcj2lc5z04qc2np8i7n3w82jwwk4wbgl5q35j";
        libraryHaskellDepends = [
          base base16-bytestring binary bytestring data-default-class
          directory filepath hashable lazy-hash microlens microlens-th
···
 
   "ldap-client" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-types, async, base, bytestring
-     , connection, containers, hspec, network, process, semigroups, stm
-     , text
+     , connection, containers, fail, hspec, network, process, semigroups
+     , stm, text
      }:
      mkDerivation {
        pname = "ldap-client";
-       version = "0.2.0";
-       sha256 = "0vs6n3q9svwhcp6853ipxmw1anmy8qfy3xajjsf7h4pjnqzy7g88";
+       version = "0.3.0";
+       sha256 = "0fii1yi3mn1dqvzbsx63fqrb53v81a7d2gqn3xma8v9vsp9nxv7v";
        libraryHaskellDepends = [
          asn1-encoding asn1-types async base bytestring connection
-         containers network semigroups stm text
+         containers fail network semigroups stm text
        ];
        testHaskellDepends = [ base bytestring hspec process semigroups ];
        description = "Pure Haskell LDAP Client Library";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "lens-family_2_0_0" = callPackage
+    ({ mkDerivation, base, containers, lens-family-core, mtl
+     , transformers
+     }:
+     mkDerivation {
+       pname = "lens-family";
+       version = "2.0.0";
+       sha256 = "1nq3dwkrjyqafbv4gvwwgz6ih8y4x9bks11jhljh43q3qnjz54v7";
+       libraryHaskellDepends = [
+         base containers lens-family-core mtl transformers
+       ];
+       description = "Lens Families";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "lens-family-core" = callPackage
     ({ mkDerivation, base, containers, transformers }:
      mkDerivation {
···
        libraryHaskellDepends = [ base containers transformers ];
        description = "Haskell 98 Lens Families";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "lens-family-core_2_0_0" = callPackage
+    ({ mkDerivation, base, containers, transformers }:
+     mkDerivation {
+       pname = "lens-family-core";
+       version = "2.0.0";
+       sha256 = "0ni6s873hy2h3b316835ssmlyr05yinb3a8jq5b01p9ppp9zrd0r";
+       libraryHaskellDepends = [ base containers transformers ];
+       description = "Haskell 2022 Lens Families";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "lens-family-th" = callPackage
···
      }) {};
 
   "lens-regex-pcre" = callPackage
-    ({ mkDerivation, base, hspec, lens, pcre-heavy, pcre-light
-     , template-haskell, text
+    ({ mkDerivation, base, bytestring, hspec, lens, pcre-heavy
+     , pcre-light, template-haskell, text
      }:
      mkDerivation {
        pname = "lens-regex-pcre";
-       version = "0.3.0.0";
-       sha256 = "1010nhik7vfk6gll9h8cwnq7mx3v4gnl3nlyn7ma5y93ghq0ckvs";
+       version = "0.3.1.0";
+       sha256 = "1fbhwzs7mwz9c0l3p34zcgfvqxwxlhr3abz9gawlraiiypmz0iby";
        libraryHaskellDepends = [
-         base lens pcre-heavy pcre-light template-haskell text
+         base bytestring lens pcre-heavy pcre-light template-haskell text
        ];
        testHaskellDepends = [
          base hspec lens pcre-heavy pcre-light template-haskell text
        ];
+       description = "A lensy interface to regular expressions";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        pname = "libarchive";
        version = "1.0.5.1";
        sha256 = "1fchnvs03hg513v7a45a3qbfr3kbh3nmqjqljzr2y1mg2ghkr7cz";
+       revision = "4";
+       editedCabalFile = "0wzw962gl9lm5faaa86z4q7s9cbzqn346cmlbhr518dbnw7nv31d";
        libraryHaskellDepends = [
          base bytestring composition-prelude dlist filepath
        ];
···
        pname = "linearmap-category";
        version = "0.3.5.0";
        sha256 = "0qmd0nz343j3j3kprbhwfkglcswfcawfy0y6g4ai6nzdga42nfrf";
-       revision = "2";
-       editedCabalFile = "129fgr6m9691cd3nzy1magiwd7f9x2jip96pqj10d0lgb931frzg";
+       revision = "3";
+       editedCabalFile = "0b4m77csdsi5wgvbclza2arps5s0xgg0iibiy8kwax55ml04kkvp";
        libraryHaskellDepends = [
          base call-stack constrained-categories containers
          free-vector-spaces ieee754 lens linear manifolds-core semigroups
···
        broken = true;
      }) {};
 
+  "log4hs" = callPackage
+    ({ mkDerivation, aeson, base, containers, data-default, directory
+     , filepath, hspec, hspec-core, process, QuickCheck
+     , template-haskell, text, time, unordered-containers
+     }:
+     mkDerivation {
+       pname = "log4hs";
+       version = "0.0.2.0";
+       sha256 = "08z8lyh0q4wpxvvzbf1w0bxvbm90ic4wzxyac2b0ddm4zn8zdn9s";
+       libraryHaskellDepends = [
+         aeson base containers data-default directory filepath
+         template-haskell text time unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson base containers data-default directory filepath hspec
+         hspec-core process QuickCheck template-haskell text time
+         unordered-containers
+       ];
+       description = "A python logging style log library";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "logentries" = callPackage
     ({ mkDerivation, base, bytestring, data-default, fast-logger, hspec
      , network, stm, uuid-types, wai, wai-extra
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "logict_0_7_0_1" = callPackage
+  "logict_0_7_0_2" = callPackage
     ({ mkDerivation, base, mtl, tasty, tasty-hunit }:
      mkDerivation {
        pname = "logict";
-       version = "0.7.0.1";
-       sha256 = "1zzcfxdl156rrr120vjcn2wawa2qdrninm6d4mxj215ig1a3aak5";
+       version = "0.7.0.2";
+       sha256 = "1xfgdsxg0lp8m0a2cb83rcxrnnc37asfikay2kydi933anh9ihfc";
        libraryHaskellDepends = [ base mtl ];
        testHaskellDepends = [ base mtl tasty tasty-hunit ];
        description = "A backtracking logic-programming monad";
···
      }:
      mkDerivation {
        pname = "mandrill";
-       version = "0.5.3.5";
-       sha256 = "0yh7r3wrzpzm3iv0zvs6nzf36hwv0y7xlsz6cy3dlnyrr5jbsb1i";
+       version = "0.5.3.6";
+       sha256 = "1jvgxhc3x7867cryvsbpj7hks9syhpqbwyh4y0v6b0yp0xil8qrl";
        libraryHaskellDepends = [
          aeson base base64-bytestring blaze-html bytestring containers
          email-validate http-client http-client-tls http-types microlens-th
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "massiv_0_3_6_0" = callPackage
-    ({ mkDerivation, async, base, bytestring, Cabal, cabal-doctest
-     , containers, data-default, data-default-class, deepseq, doctest
-     , exceptions, hspec, mersenne-random-pure64, primitive, QuickCheck
-     , random, scheduler, splitmix, template-haskell, unliftio
-     , unliftio-core, vector
+  "massiv_0_4_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, cabal-doctest
+     , data-default-class, deepseq, doctest, exceptions
+     , mersenne-random-pure64, primitive, QuickCheck, random, scheduler
+     , splitmix, template-haskell, unliftio-core, vector
      }:
      mkDerivation {
        pname = "massiv";
-       version = "0.3.6.0";
-       sha256 = "00bjgrb7pa59i8wmbjgscq0jw4x3r1gjvpns7sd58ffa8zfd6sgc";
+       version = "0.4.0.0";
+       sha256 = "077w18fxgq50h1ylbalf6lbam2rcqp4a3b6qr21ac63514dyvyfz";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bytestring data-default-class deepseq exceptions primitive
          scheduler unliftio-core vector
        ];
        testHaskellDepends = [
-         async base bytestring containers data-default deepseq doctest hspec
-         mersenne-random-pure64 QuickCheck random scheduler splitmix
-         template-haskell unliftio vector
+         base doctest mersenne-random-pure64 QuickCheck random splitmix
+         template-haskell
        ];
        description = "Massiv (Массив) is an Array Library";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "massiv-test" = callPackage
+    ({ mkDerivation, base, bytestring, containers, data-default
+     , data-default-class, deepseq, exceptions, genvalidity-hspec, hspec
+     , massiv, primitive, QuickCheck, scheduler, unliftio, vector
+     }:
+     mkDerivation {
+       pname = "massiv-test";
+       version = "0.1.0";
+       sha256 = "08rs0j773c3jxnj6akh8gaywfz2g10w1ddmcqpkci5bqqjmqqf85";
+       libraryHaskellDepends = [
+         base bytestring data-default-class deepseq exceptions hspec massiv
+         primitive QuickCheck scheduler unliftio vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers data-default deepseq genvalidity-hspec
+         hspec massiv QuickCheck scheduler vector
+       ];
+       description = "Library that contains generators, properties and tests for Massiv Array Library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "master-plan" = callPackage
     ({ mkDerivation, base, diagrams, diagrams-lib, diagrams-rasterific
      , hspec, megaparsec, mtl, optparse-applicative, QuickCheck
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "mega-sdist_0_4_0_0" = callPackage
-    ({ mkDerivation, base, bytestring, optparse-simple, pantry-tmp
-     , path, path-io, rio, rio-orphans, yaml
+  "mega-sdist_0_4_0_1" = callPackage
+    ({ mkDerivation, base, bytestring, optparse-simple, pantry, path
+     , path-io, rio, rio-orphans, yaml
      }:
      mkDerivation {
        pname = "mega-sdist";
-       version = "0.4.0.0";
-       sha256 = "0d8z0jj4xm091zdlydkp5fgs22xrjrsydfm9czfr79pmcx83bdi4";
+       version = "0.4.0.1";
+       sha256 = "191saxmdh3705rhci7lz7qzcdzv2zvw9bwa7f5d62500azi13j8v";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base bytestring optparse-simple pantry-tmp path path-io rio
-         rio-orphans yaml
+         base bytestring optparse-simple pantry path path-io rio rio-orphans
+         yaml
        ];
        description = "Handles uploading to Hackage from mega repos";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "membrain" = callPackage
+    ({ mkDerivation, base, doctest, Glob, hedgehog, hspec, type-spec }:
+     mkDerivation {
+       pname = "membrain";
+       version = "0.0.0.0";
+       sha256 = "01wv5i3kgbpmwjnjk5xgkpm3j5wazlz1f05kmm523wf34xivp498";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base doctest Glob hedgehog hspec type-spec
+       ];
+       description = "Type-safe memory units";
+       license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "memcache" = callPackage
     ({ mkDerivation, base, binary, blaze-builder, bytestring, criterion
      , data-default-class, hashable, network, resource-pool, time
···
      }:
      mkDerivation {
        pname = "memdb";
-       version = "1.0.0.0";
-       sha256 = "1rm1ijhhiyznbqidcpa1796lzj35dhi4jb0a2qbrvgim329ymsr2";
+       version = "1.0.0.3";
+       sha256 = "082i381qyba51zkv4fqkn3mdhmya39pz8pw69m02c3hnp5vr4n4c";
        libraryHaskellDepends = [ base bytestring cereal vector ];
        testHaskellDepends = [
          base bytestring cereal hspec QuickCheck vector
···
        pname = "microlens-process";
        version = "0.2.0.0";
        sha256 = "05bkm3nhiv2mprds9xlmmnzll91hn76navb9h9kc9nl5rnq4nwrn";
-       revision = "2";
-       editedCabalFile = "02h97gnxwsn20npxsc0mjhyv5s8fj41xkm18xwvcqcq7a4cj8jnw";
+       revision = "4";
+       editedCabalFile = "00dhcr2czcx986a4lijmlbrxk2wm059mmbh63qs48wb6z4rrsg7y";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [ base filepath microlens process ];
        testHaskellDepends = [ base doctest microlens process ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "minecraft" = callPackage
+    ({ mkDerivation }:
+     mkDerivation {
+       pname = "minecraft";
+       version = "0.0.0.0";
+       sha256 = "07h6hgq4k1wm4ldwb29fgmmbl9ygrlbq3qv3ymfvc25l5rvgss4h";
+       doHaddock = false;
+       description = "TBA";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "minecraft-data" = callPackage
     ({ mkDerivation, array, base, bytestring, cereal, containers, lens
      , mtl, nbt, pipes, pipes-bytestring, pipes-cereal, pipes-parse
···
      }:
      mkDerivation {
        pname = "minecraft-data";
-       version = "0.1.0.0";
-       sha256 = "1p0lci3b3lwcd6j13bvsscz7ar5vskvhkpj8gy4fp8d1pak2adwr";
+       version = "0.1.0.1";
+       sha256 = "02ispnzvxjazjy76bqpils6jmy37l4v61l1wcklvvsvkb72yc39n";
        libraryHaskellDepends = [
          array base bytestring cereal containers lens mtl nbt pipes
          pipes-bytestring pipes-cereal pipes-parse pipes-zlib text text-show
···
        broken = true;
      }) {};
 
-  "minio-hs_1_3_1" = callPackage
+  "minio-hs_1_5_0" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring
-     , case-insensitive, conduit, conduit-extra, connection, containers
-     , cryptonite, cryptonite-conduit, digest, directory, exceptions
-     , filepath, http-client, http-client-tls, http-conduit, http-types
-     , ini, memory, protolude, QuickCheck, raw-strings-qq, resourcet
-     , retry, tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck
-     , temporary, text, time, transformers, unliftio, unliftio-core
+     , case-insensitive, conduit, conduit-extra, connection, cryptonite
+     , cryptonite-conduit, digest, directory, exceptions, filepath
+     , http-client, http-client-tls, http-conduit, http-types, ini
+     , memory, protolude, QuickCheck, raw-strings-qq, resourcet, retry
+     , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck, temporary
+     , text, time, transformers, unliftio, unliftio-core
      , unordered-containers, xml-conduit
      }:
      mkDerivation {
        pname = "minio-hs";
-       version = "1.3.1";
-       sha256 = "1z553cpflxmr5hy723bgmwyq061fpivi1jw0vq64x1i0bz0q1llp";
+       version = "1.5.0";
+       sha256 = "0qp8zl7f055lpchg8abcc27jq4s0nn14qp474qrj4wdmynfi8bc8";
        libraryHaskellDepends = [
          aeson base base64-bytestring binary bytestring case-insensitive
-         conduit conduit-extra connection containers cryptonite
-         cryptonite-conduit digest directory exceptions filepath http-client
-         http-client-tls http-conduit http-types ini memory protolude
-         raw-strings-qq resourcet retry text time transformers unliftio
-         unliftio-core unordered-containers xml-conduit
+         conduit conduit-extra connection cryptonite cryptonite-conduit
+         digest directory exceptions filepath http-client http-client-tls
+         http-conduit http-types ini memory protolude raw-strings-qq
+         resourcet retry text time transformers unliftio unliftio-core
+         unordered-containers xml-conduit
        ];
        testHaskellDepends = [
          aeson base base64-bytestring binary bytestring case-insensitive
-         conduit conduit-extra connection containers cryptonite
-         cryptonite-conduit digest directory exceptions filepath http-client
-         http-client-tls http-conduit http-types ini memory protolude
-         QuickCheck raw-strings-qq resourcet retry tasty tasty-hunit
-         tasty-quickcheck tasty-smallcheck temporary text time transformers
-         unliftio unliftio-core unordered-containers xml-conduit
+         conduit conduit-extra connection cryptonite cryptonite-conduit
+         digest directory exceptions filepath http-client http-client-tls
+         http-conduit http-types ini memory protolude QuickCheck
+         raw-strings-qq resourcet retry tasty tasty-hunit tasty-quickcheck
+         tasty-smallcheck temporary text time transformers unliftio
+         unliftio-core unordered-containers xml-conduit
        ];
        description = "A MinIO Haskell Library for Amazon S3 compatible cloud storage";
        license = stdenv.lib.licenses.asl20;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "miso_1_2_0_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, http-api-data
+     , http-types, lucid, network-uri, servant, servant-lucid, text
+     , transformers, vector
+     }:
+     mkDerivation {
+       pname = "miso";
+       version = "1.2.0.0";
+       sha256 = "08yhr5hxrvgqdc32yz2j3mix7s8q5bzycld3kd4rfcy2h4h72962";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers http-api-data http-types lucid
+         network-uri servant servant-lucid text transformers vector
+       ];
+       description = "A tasty Haskell front-end framework";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "miso-action-logger" = callPackage
     ({ mkDerivation, aeson, base, ghcjs-base, miso }:
      mkDerivation {
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "monad-metrics-extensible" = callPackage
+    ({ mkDerivation, base, dependent-map, dependent-sum, ekg, ekg-core
+     , exceptions, hspec, mtl, stm, text
+     }:
+     mkDerivation {
+       pname = "monad-metrics-extensible";
+       version = "0.1.0.1";
+       sha256 = "044hvhnf7wsgd18cac2j3bfw2vbxfnra736l6qndfx07mkv1nz5n";
+       libraryHaskellDepends = [
+         base dependent-map dependent-sum ekg ekg-core exceptions mtl stm
+         text
+       ];
+       testHaskellDepends = [
+         base dependent-map dependent-sum ekg ekg-core exceptions hspec mtl
+         stm text
+       ];
+       description = "An extensible and type-safe wrapper around EKG metrics";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "monad-mock" = callPackage
     ({ mkDerivation, base, constraints, exceptions, haskell-src-exts
      , haskell-src-meta, hspec, monad-control, mtl, template-haskell
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "monoidal-containers_0_5_0_0" = callPackage
+    ({ mkDerivation, aeson, base, containers, deepseq, hashable, lens
+     , newtype, semigroups, these, unordered-containers
+     }:
+     mkDerivation {
+       pname = "monoidal-containers";
+       version = "0.5.0.0";
+       sha256 = "0dayylvsn6mcgyis04nl4384sg8vr4mrnvf1wvfhb5pip3v7hl7a";
+       libraryHaskellDepends = [
+         aeson base containers deepseq hashable lens newtype semigroups
+         these unordered-containers
+       ];
+       description = "Containers with monoidal accumulation";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "monoidplus" = callPackage
     ({ mkDerivation, base, contravariant, semigroups, transformers }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "ms-tds";
-       version = "0.2.0.0";
-       sha256 = "0675h4w8nayvh2gm644anz8sqk37b1n5ia4w5fgyaf9y6drafyda";
+       version = "0.3.0.0";
+       sha256 = "0pdv9x6743qaqk6fcm02hfrr09ckwbd9fpgzgmgmgnqhqxm0y9y6";
        libraryHaskellDepends = [
          array base binary bytestring crypto-random data-default-class mtl
          network template-haskell text time tls uuid-types x509-store
···
      }:
      mkDerivation {
        pname = "mssql-simple";
-       version = "0.2.0.0";
-       sha256 = "1pqw2kr8fyy62kmamvm600zsqri9d2201kixvr6gdy6z0ivyl0sz";
+       version = "0.3.0.0";
+       sha256 = "0wssw1d3ki95b83ww6brx8apk7s86vnzgwlh91xvfdp8hkqygx1q";
        libraryHaskellDepends = [
          base binary bytestring hostname ms-tds network text time tls
        ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "mwc-probability_2_1_0" = callPackage
+    ({ mkDerivation, base, mwc-random, primitive, transformers }:
+     mkDerivation {
+       pname = "mwc-probability";
+       version = "2.1.0";
+       sha256 = "0ac4pr2l0p48a0n6jym445c8h7n2nf1pqkhrz6cd1rjbmrk5mbm3";
+       libraryHaskellDepends = [ base mwc-random primitive transformers ];
+       description = "Sampling function-based probability distributions";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "mwc-probability-transition" = callPackage
     ({ mkDerivation, base, exceptions, ghc-prim, hspec, logging-effect
      , mtl, mwc-probability, primitive, QuickCheck, transformers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "named-sop" = callPackage
+    ({ mkDerivation, base, singletons, tasty, tasty-hunit, text }:
+     mkDerivation {
+       pname = "named-sop";
+       version = "0.2.0.0";
+       sha256 = "1yz4cp19nf44cscfzhwsw7xigq07sxbvzfw5v5l3jgsjxi5xw9ad";
+       libraryHaskellDepends = [ base singletons text ];
+       testHaskellDepends = [ base tasty tasty-hunit ];
+       description = "Dependently-typed sums and products, tagged by field name";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "namelist" = callPackage
     ({ mkDerivation, base, case-insensitive, data-default-class, parsec
      , QuickCheck, tasty, tasty-hunit, tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "naqsha";
-       version = "0.3.0.0";
-       sha256 = "1564aff7ynqilqa9aiv1ih3dl9rimvvzyzqczx1bb94iznrfzghi";
-       isLibrary = false;
-       isExecutable = false;
+       version = "0.3.0.1";
+       sha256 = "0wg2vvik0yhaqyla64m3mcrv0fkrs92dgkrq5pzq78xjycnm7q1r";
        libraryHaskellDepends = [ base bytestring groups vector ];
        testHaskellDepends = [
          base bytestring groups hspec hspec-discover HUnit QuickCheck vector
···
   "net-spider" = callPackage
     ({ mkDerivation, aeson, base, containers, data-interval, doctest
      , doctest-discover, extended-reals, greskell, greskell-websocket
-     , hashable, hspec, monad-logger, safe-exceptions, text, time
-     , unordered-containers, vector
+     , hashable, hspec, monad-logger, safe-exceptions, scientific, text
+     , time, unordered-containers, vector
      }:
      mkDerivation {
        pname = "net-spider";
-       version = "0.3.0.0";
-       sha256 = "1wz37rrjpk4v8h1mh6pbld84f9kp5h3qcjxxh6fgbkij5l4g7m77";
+       version = "0.3.1.1";
+       sha256 = "0p0vwj438mbiwjgn7sqf3cb4bl48ygwi8n61wap9a9nc6fwrjmi8";
        libraryHaskellDepends = [
          aeson base containers data-interval extended-reals greskell
-         greskell-websocket hashable monad-logger safe-exceptions text time
-         unordered-containers vector
+         greskell-websocket hashable monad-logger safe-exceptions scientific
+         text time unordered-containers vector
        ];
        testHaskellDepends = [
-         base doctest doctest-discover hspec vector
+         aeson base doctest doctest-discover hspec text vector
        ];
        description = "A graph database middleware to maintain a time-varying graph";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "net-spider-pangraph";
-       version = "0.1.0.0";
-       sha256 = "1aiacaccml8477vmcnv9mqcrn87nyx7pbgwp7rppz7h5w0dsj8lx";
+       version = "0.1.1.0";
+       sha256 = "1j3s379ri05jg3bzhiz6d8fjvxlkz00l7mrphqmr46j4y8d9vrkv";
        libraryHaskellDepends = [
          base bytestring greskell net-spider pangraph text time
        ];
···
 
   "net-spider-rpl" = callPackage
     ({ mkDerivation, aeson, base, greskell, hashable, hspec, ip
-     , net-spider, net-spider-pangraph, text, time
+     , net-spider, text, time
      }:
      mkDerivation {
        pname = "net-spider-rpl";
-       version = "0.1.0.0";
-       sha256 = "0basbgcdkjksg9p2s5s0whnbas3w3wnrkkdsr907m8gppkdk6i69";
+       version = "0.2.1.0";
+       sha256 = "07f51ym5v1mpa1v6249sgkxqd8y52fdgs8l2r59mxil1ph6al7x1";
        libraryHaskellDepends = [
-         aeson base greskell hashable ip net-spider net-spider-pangraph text
-         time
+         aeson base greskell hashable ip net-spider text time
        ];
        testHaskellDepends = [ base hspec net-spider text ];
        description = "NetSpider data model and utility for RPL networks";
···
        broken = true;
      }) {};
 
+  "network-run" = callPackage
+    ({ mkDerivation, base, network }:
+     mkDerivation {
+       pname = "network-run";
+       version = "0.0.1";
+       sha256 = "1yc5hpcadab1dzvi9wz6v25v7wp5j07a36wdabrxi1pwy4gania5";
+       libraryHaskellDepends = [ base network ];
+       description = "Simple network runner library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "network-server" = callPackage
     ({ mkDerivation, base, network, unix }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "ngx-export-tools";
-       version = "0.4.5.0";
-       sha256 = "1775syhp5pgm6sdn3x8y3zqzvqrwypl07xm6rkv34sbw5x84mmmv";
+       version = "0.4.6.0";
+       sha256 = "0bvyh1b8q2mh2labaykc7lndr2rfhzmkw8c7b56pxsa2fypfl232";
        libraryHaskellDepends = [
          aeson base binary bytestring ngx-export safe template-haskell
        ];
···
        broken = true;
      }) {};
 
+  "no-value" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "no-value";
+       version = "1.0.0.0";
+       sha256 = "1jczx8d4ah74wiishdcv335hlr0330wwq0vfb5rv4gmrvbpkgllf";
+       libraryHaskellDepends = [ base ];
+       description = "A type class for choosing sentinel-like values";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "noether" = callPackage
   "mega-sdist" = callPackage
      , criterion, deepseq, ghc-prim, hashable, hedgehog, mtl, mtl-compat
···
        pname = "number-show";
        version = "0.1.0.0";
        sha256 = "01lywbcqg46wrd3qy0jikkh1p45yflypf1vcmrw75qpwji2afjry";
-       revision = "1";
-       editedCabalFile = "0wzim9xpm78rd71jcgfrz427rjvyvrb7qilkcvw78si7mj9wsxcc";
+       revision = "2";
+       editedCabalFile = "1lsxi6704g6svw0834haggp6j97kb6r51583lr2a3kn1ni2zh60c";
        libraryHaskellDepends = [ base microlens microlens-th ];
        description = "Flexible and accurate (for a given precision) numerical->string conversion";
        license = stdenv.lib.licenses.gpl3;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "optparse-enum" = callPackage
+    ({ mkDerivation, base, enum-text, fmt, optparse-applicative, text
+     }:
+     mkDerivation {
+       pname = "optparse-enum";
+       version = "1.0.0.0";
+       sha256 = "0d3wpfss1nm42hjn8l7x34ksa7yx5ccc4iglbfvln0rkbqdsjh13";
+       libraryHaskellDepends = [
+         base enum-text fmt optparse-applicative text
+       ];
+       description = "An enum-text based toolkit for optparse-applicative";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "optparse-generic" = callPackage
     ({ mkDerivation, base, bytestring, Only, optparse-applicative
      , semigroups, system-filepath, text, time, transformers, void
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "outsort" = callPackage
+    ({ mkDerivation, async, base, bytestring, conduit
+     , conduit-algorithms, conduit-combinators, conduit-extra
+     , containers, deepseq, directory, exceptions, filemanip, filepath
+     , MissingH, primitive, resourcet, safe, safeio, temporary, text
+     , transformers, transformers-base, vector, vector-algorithms
+     }:
+     mkDerivation {
+       pname = "outsort";
+       version = "0.1.0";
+       sha256 = "13iw9hgsmz1j4lm4ahpi9kjgf3pcayll9fpi3fga48474hpz7gff";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         async base bytestring conduit conduit-algorithms
+         conduit-combinators conduit-extra containers deepseq directory
+         exceptions filemanip filepath MissingH primitive resourcet safe
+         safeio temporary text transformers transformers-base vector
+         vector-algorithms
+       ];
+       description = "External sorting package based on Conduit";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "overhang" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "packed-multikey-map";
        version = "0.1.0.0";
        sha256 = "19bh697xazsi22krwjgy83hv1pscnaqx544d5pk0q71wnync5m89";
+       revision = "1";
+       editedCabalFile = "1z6bx1qga02f33l194k2m45gs9cddq9q7q52b2vhv408n09jixrn";
        libraryHaskellDepends = [
          base constraints containers QuickCheck transformers vector
        ];
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "pandora";
-       version = "0.1.7";
-       sha256 = "1wmp5c7b9scdrhrh50cpjfpcw1riw4kxs1vy935mzwja1y4zalsj";
+       version = "0.2.0";
+       sha256 = "0p46z3imh618v7i2734b5nlg9nx3hw4imjchqsx2l7nvkrpkgn64";
        description = "A box of patterns and paradigms";
        license = stdenv.lib.licenses.mit;
      }) {};
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "pantry" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, array, base, base-orphans
+     , base64-bytestring, bytestring, Cabal, conduit, conduit-extra
+     , containers, contravariant, cryptonite, cryptonite-conduit
+     , deepseq, digest, directory, exceptions, filelock, filepath
+     , generic-deriving, ghc-prim, hackage-security, hashable, hedgehog
+     , hpack, hspec, http-client, http-client-tls, http-conduit
+     , http-download, http-types, integer-gmp, memory, mono-traversable
+     , mtl, network, network-uri, path, path-io, persistent
+     , persistent-sqlite, persistent-template, primitive, QuickCheck
+     , raw-strings-qq, resourcet, rio, rio-orphans, rio-prettyprint
+     , safe, syb, tar-conduit, template-haskell, text, text-metrics
+     , th-lift, th-lift-instances, th-orphans, th-reify-many
+     , th-utilities, time, transformers, unix-compat, unliftio
+     , unordered-containers, vector, yaml, zip-archive
+     }:
+     mkDerivation {
+       pname = "pantry";
+       version = "0.1.1.1";
+       sha256 = "082p2shapgnv10qjm77bpn0y6p6582n38xcgirh2l8mhs1yqflyg";
+       libraryHaskellDepends = [
+         aeson ansi-terminal array base base-orphans base64-bytestring
+         bytestring Cabal conduit conduit-extra containers contravariant
+         cryptonite cryptonite-conduit deepseq digest directory filelock
+         filepath generic-deriving ghc-prim hackage-security hashable hpack
+         http-client http-client-tls http-conduit http-download http-types
+         integer-gmp memory mono-traversable mtl network network-uri path
+         path-io persistent persistent-sqlite persistent-template primitive
+         resourcet rio rio-orphans rio-prettyprint safe syb tar-conduit
+         template-haskell text text-metrics th-lift th-lift-instances
+         th-orphans th-reify-many th-utilities time transformers unix-compat
+         unliftio unordered-containers vector yaml zip-archive
+       ];
+       testHaskellDepends = [
+         aeson ansi-terminal array base base-orphans base64-bytestring
+         bytestring Cabal conduit conduit-extra containers contravariant
+         cryptonite cryptonite-conduit deepseq digest directory exceptions
+         filelock filepath generic-deriving ghc-prim hackage-security
+         hashable hedgehog hpack hspec http-client http-client-tls
+         http-conduit http-download http-types integer-gmp memory
+         mono-traversable mtl network network-uri path path-io persistent
+         persistent-sqlite persistent-template primitive QuickCheck
+         raw-strings-qq resourcet rio rio-orphans rio-prettyprint safe syb
+         tar-conduit template-haskell text text-metrics th-lift
+         th-lift-instances th-orphans th-reify-many th-utilities time
+         transformers unix-compat unliftio unordered-containers vector yaml
+         zip-archive
+       ];
+       description = "Content addressable Haskell package management";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "pantry-tmp" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, array, base, base-orphans
      , base64-bytestring, bytestring, Cabal, conduit, conduit-extra
···
        pname = "pantry-tmp";
        version = "0.1.0.0";
        sha256 = "18b2ac5kb6xzkxa2c5hhl6n37npxcxzxghi0p5wnv5rps3ahsmnn";
-       revision = "3";
-       editedCabalFile = "12k0lqpc530ai9gb1ldx7l62qi86z4qc2s1bzif8fwaflk4c7ax6";
+       revision = "4";
+       editedCabalFile = "0hiashi78cak635jk74bk6m1dwdgyp8m0j5bzg18i776mb1zn09y";
        libraryHaskellDepends = [
          aeson ansi-terminal array base base-orphans base64-bytestring
          bytestring Cabal conduit conduit-extra containers contravariant
···
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
+     }) {};
+
+  "par-traverse" = callPackage
+    ({ mkDerivation, base, directory, filepath, parallel-io }:
+     mkDerivation {
+       pname = "par-traverse";
+       version = "0.2.0.0";
+       sha256 = "1cbanrhaad3fq2kkpdkb3rh7c8qrc1v7by8v6mg4lrgghdx3msk8";
+       libraryHaskellDepends = [ base directory filepath parallel-io ];
+       description = "Traverse a directory in parallel";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "para" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "parser-combinators_1_1_0" = callPackage
+  "parser-combinators_1_2_0" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "parser-combinators";
-       version = "1.1.0";
-       sha256 = "149yhbnrrl108h1jinrsxni3rwrldhphpk9bbmbpr90q5fbl4xmc";
+       version = "1.2.0";
+       sha256 = "18kfg4sxighqzd64ad98xhc62sh7pd63pv7xhcj601pw922iappa";
        libraryHaskellDepends = [ base ];
        description = "Lightweight package providing commonly useful parser combinators";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "parser-combinators-tests";
-       version = "1.1.0";
-       sha256 = "0m3xgdi1q3q638zfvgpdqyrhfq9abqwjripvbdx5z9rai4whzqmz";
-       revision = "1";
-       editedCabalFile = "0adgbzpylvk9p7ylxynsdrmqhhbh5pm8ww1s3nz3czl79y8lhh47";
+       version = "1.2.0";
+       sha256 = "0ainpyrxm03brn6z27jkqp65rc1z3lza00k6mg10506qk83fa52l";
        isLibrary = false;
        isExecutable = false;
        testHaskellDepends = [
···
        ];
        description = "Terminal-based presentations using Pandoc";
        license = stdenv.lib.licenses.gpl2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "patch-combinators" = callPackage
···
     ({ mkDerivation, base, containers }:
      mkDerivation {
        pname = "patience";
-       version = "0.2.1.1";
-       sha256 = "14d6hkrkbanlv09z7dbg8q7hk5ax5mfpgzr0knmcviq02kmzbs0s";
+       version = "0.3";
+       sha256 = "1i1b37lgi31c17yrjyf8pdm4nf5lq8vw90z3rri78hf0k66d0p3i";
        libraryHaskellDepends = [ base containers ];
        description = "Patience diff and longest increasing subsequence";
        license = stdenv.lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
+  "perceptual-hash" = callPackage
+    ({ mkDerivation, base, containers, cpphs, criterion, filepath, hip
+     , optparse-applicative, par-traverse, pHash, primitive, repa, stm
+     , vector, vector-algorithms
+     }:
+     mkDerivation {
+       pname = "perceptual-hash";
+       version = "0.1.1.0";
+       sha256 = "107f5xb4wg4zmwqldw8a04byazqyzd0vkn6zl5iv4f5ii2sdb5yh";
+       revision = "1";
+       editedCabalFile = "001nr9brgk05bbhz9lw8viqrc6rgfy0rjp08fcdhn302j55j33i3";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base hip primitive repa vector vector-algorithms
+       ];
+       executableHaskellDepends = [
+         base containers filepath optparse-applicative par-traverse stm
+       ];
+       benchmarkHaskellDepends = [ base criterion ];
+       benchmarkPkgconfigDepends = [ pHash ];
+       benchmarkToolDepends = [ cpphs ];
+       description = "Find duplicate images";
+       license = stdenv.lib.licenses.bsd3;
+     }) {pHash = null;};
+
   "perdure" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, cognimeta-utils
      , collections-api, comonad-transformers, containers, cryptohash
···
      }:
      mkDerivation {
        pname = "perfect-vector-shuffle";
-       version = "0.1.0";
-       sha256 = "1nvwbmfqv9bq6423hxafjrvza6ynj3pry4m5ms1g2yf5vsx47w38";
+       version = "0.1.1";
+       sha256 = "1r9w8792r25fgyf7q7jdpnw4rmdvrjfg7g4dn2dk1d3gy4lbabig";
        libraryHaskellDepends = [
          base MonadRandom primitive random vector
        ];
···
        pname = "persistent-mongoDB";
        version = "2.8.0";
        sha256 = "12hp7cqdz672r5rhad6xvjpxhrs8v1swiz0d9n7xbn41g11a247l";
+       revision = "1";
+       editedCabalFile = "06iqf7frc5h7qvxhnxi2zirgspsmafp2ls0jw3ppzb01q0y6mgi4";
        libraryHaskellDepends = [
          aeson attoparsec base bson bytestring cereal conduit containers
          http-api-data mongoDB network path-pieces persistent resource-pool
···
        broken = true;
      }) {};
 
+  "persistent-pagination" = callPackage
+    ({ mkDerivation, base, conduit, containers, esqueleto, foldl, hspec
+     , hspec-discover, microlens, mtl, persistent, persistent-sqlite
+     , persistent-template, QuickCheck, time
+     }:
+     mkDerivation {
+       pname = "persistent-pagination";
+       version = "0.1.1.0";
+       sha256 = "1g2mn2gv9dygx4rrpxi81421dyyy9pdnzrdpqcb5sygcjsqi17ha";
+       libraryHaskellDepends = [
+         base conduit esqueleto foldl microlens mtl persistent
+       ];
+       testHaskellDepends = [
+         base conduit containers esqueleto hspec hspec-discover mtl
+         persistent persistent-sqlite persistent-template QuickCheck time
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Efficient and correct pagination for persistent or esqueleto queries";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "persistent-parser" = callPackage
     ({ mkDerivation, attoparsec, base, hspec, text }:
      mkDerivation {
···
        maintainers = with stdenv.lib.maintainers; [ psibi ];
      }) {inherit (pkgs) sqlite;};
 
-  "persistent-sqlite_2_10_1" = callPackage
+  "persistent-sqlite_2_10_4" = callPackage
     ({ mkDerivation, aeson, base, bytestring, conduit, containers
      , exceptions, fast-logger, hspec, HUnit, microlens-th, monad-logger
      , persistent, persistent-template, persistent-test, QuickCheck
···
      }:
      mkDerivation {
        pname = "persistent-sqlite";
-       version = "2.10.1";
-       sha256 = "1yan8ciljv2kkcxlc9yj97gvlgkzf1ha6369dqnr7fgk1xhr74nz";
+       version = "2.10.4";
+       sha256 = "0x4b327h2gqhccy7yw5sa8mn8xfc4zb5kqwx98nr9yk7f1s0fr79";
        configureFlags = [ "-fsystemlib" ];
        isLibrary = true;
        isExecutable = true;
···
        maintainers = with stdenv.lib.maintainers; [ psibi ];
      }) {};
 
-  "persistent-template_2_7_1" = callPackage
+  "persistent-template_2_7_2" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, criterion
      , deepseq, deepseq-generics, file-embed, hspec, http-api-data
      , monad-control, monad-logger, path-pieces, persistent, QuickCheck
···
      }:
      mkDerivation {
        pname = "persistent-template";
-       version = "2.7.1";
-       sha256 = "1yki4dvfk2p5cs2gfdnplsfyb1cxakhrdfjxgdgbnc0xxicbzx42";
+       version = "2.7.2";
+       sha256 = "04fpxsbj78gy51bl3jcfg70aaha92v0r48bjwq4pg7ln3cic95i8";
        libraryHaskellDepends = [
          aeson base bytestring containers http-api-data monad-control
          monad-logger path-pieces persistent template-haskell text
···
      }:
      mkDerivation {
        pname = "pinboard-notes-backup";
-       version = "1.0.4";
-       sha256 = "0frlxz9mqd0dypi3f6w926sngwp4jhrz47zr35zdxwrvv64z29g7";
+       version = "1.0.4.1";
+       sha256 = "1a0lw43pjfz18aplm2frljwaww37pm2ashxi59j6l5n32lg5573j";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
 
   "ping" = callPackage
     ({ mkDerivation, base, cpu, ip, posix-api, primitive
-     , primitive-containers, stm, transformers
+     , primitive-addr, primitive-containers, stm, transformers
      }:
      mkDerivation {
        pname = "ping";
-       version = "0.1.0.2";
-       sha256 = "1cjgs571q5p5r5j94w8cax20r951v08x3cq5a2wd5r852bbgg9ww";
+       version = "0.1.0.3";
+       sha256 = "1h57p53vakjxm3g6inp9wvj5pp71qb0mpcrxbaa707w8v9lyvwwi";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
-         base cpu ip posix-api primitive primitive-containers stm
-         transformers
+         base cpu ip posix-api primitive primitive-addr primitive-containers
+         stm transformers
        ];
        description = "icmp echo requests";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
+  "piped" = callPackage
+    ({ mkDerivation, base, conduit, gauge, microlens-platform, mtl
+     , quickcheck-instances, tasty, tasty-discover, tasty-golden
+     , tasty-hunit, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "piped";
+       version = "0.1.0.0";
+       sha256 = "0f7j4mzdcmw7lnmq73hr6wfi64jjg350bmf0w1pf1rgma2wb9cl0";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base mtl ];
+       testHaskellDepends = [
+         base conduit gauge microlens-platform mtl quickcheck-instances
+         tasty tasty-discover tasty-golden tasty-hunit tasty-quickcheck
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Conduit with a smaller core";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "pipeline" = callPackage
     ({ mkDerivation, base, transformers }:
      mkDerivation {
···
        pname = "pipes-group";
        version = "1.0.12";
        sha256 = "1issfj3syi6lfbcdn3bhlbnlh86s92ldsb04c4ac69xipsgyhwqk";
+       revision = "1";
+       editedCabalFile = "0ws99n692c9km68n9y3x0b5bqdg3b47sva04nx9a4xdqr8p5akps";
        libraryHaskellDepends = [
          base free pipes pipes-parse transformers
        ];
···
      }:
      mkDerivation {
        pname = "poly";
-       version = "0.3.0.0";
-       sha256 = "0kwh1n9b6zh21kg2036v02jpr9xvvay6x72b044j4la65pal5h8i";
+       version = "0.3.1.0";
+       sha256 = "1c8xnkqxwzbpx01clz9spz9zwa18qhsbvscrc381r0f46cjax2ph";
        libraryHaskellDepends = [
          base primitive semirings vector vector-algorithms
        ];
···
     ({ mkDerivation, async, base, containers, criterion, doctest
      , first-class-families, free, freer-simple, hspec, hspec-discover
      , inspection-testing, mtl, syb, template-haskell, th-abstraction
-     , transformers, type-errors, unagi-chan
+     , transformers, type-errors, type-errors-pretty, unagi-chan
      }:
      mkDerivation {
        pname = "polysemy";
-       version = "0.7.0.0";
-       sha256 = "0p9f5m2invppncmd1d9sim1kvnzcgramnq3y1vr0bisg02y0c8dc";
+       version = "1.0.0.0";
+       sha256 = "1y63vwrmmany62ci2sdd8kfmkrigk0vds2kjpxmyh9nsvw5fv576";
        libraryHaskellDepends = [
          async base containers first-class-families mtl syb template-haskell
-         th-abstraction transformers type-errors unagi-chan
+         th-abstraction transformers type-errors type-errors-pretty
+         unagi-chan
        ];
        testHaskellDepends = [
          async base containers doctest first-class-families hspec
          inspection-testing mtl syb template-haskell th-abstraction
-         transformers type-errors unagi-chan
+         transformers type-errors type-errors-pretty unagi-chan
        ];
        testToolDepends = [ hspec-discover ];
        benchmarkHaskellDepends = [
          async base containers criterion first-class-families free
          freer-simple mtl syb template-haskell th-abstraction transformers
-         type-errors unagi-chan
+         type-errors type-errors-pretty unagi-chan
        ];
        description = "Higher-order, low-boilerplate, zero-cost free monads";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "polysemy-zoo" = callPackage
-    ({ mkDerivation, base, constraints, containers, hspec
-     , hspec-discover, mtl, polysemy, polysemy-plugin, random
-     , reflection, text
+    ({ mkDerivation, async, base, binary, bytestring, constraints
+     , containers, ghc-prim, hedis, hspec, hspec-discover, mtl, polysemy
+     , polysemy-plugin, random, reflection
      }:
      mkDerivation {
        pname = "polysemy-zoo";
-       version = "0.3.0.0";
-       sha256 = "1ww5qsxpz1h5jb1444fm2hnzkikcpnpf7gw4v1vkn8bh6cnmpxfy";
+       version = "0.5.0.1";
+       sha256 = "06ggm3qinabwp5bha858anwdvw726wzl738wpgf1kd9mgivbv53w";
        libraryHaskellDepends = [
-         base constraints containers mtl polysemy polysemy-plugin random
-         reflection
+         async base binary bytestring constraints containers ghc-prim hedis
+         mtl polysemy polysemy-plugin random reflection
        ];
        testHaskellDepends = [
-         base constraints containers hspec mtl polysemy polysemy-plugin
-         random reflection text
+         async base binary bytestring constraints containers ghc-prim hedis
+         hspec mtl polysemy polysemy-plugin random reflection
        ];
        testToolDepends = [ hspec-discover ];
        description = "Experimental, user-contributed effects and interpreters for polysemy";
···
      }:
      mkDerivation {
        pname = "posix-api";
-       version = "0.3.0.0";
-       sha256 = "172271qakd2w8hg68m57p8avwwb2cm8hds0qzq53559p2n1z69xq";
+       version = "0.3.2.0";
+       sha256 = "1ki45p31cc1zplzsi9kln85rm556rwk5yvwgsb75bcgqwg6xpcl8";
        libraryHaskellDepends = [
          base primitive primitive-addr primitive-offset primitive-unlifted
        ];
-       testHaskellDepends = [ base primitive tasty tasty-hunit ];
+       testHaskellDepends = [
+         base primitive primitive-unlifted tasty tasty-hunit
+       ];
        description = "posix bindings";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "postgresql-lo-stream";
-       version = "0.1.1.0";
-       sha256 = "196f6lz8i8y0cfnd4lqjky69wpi0mc2jfs7jz5v0j3r15jbs5212";
+       version = "0.1.1.1";
+       sha256 = "0m2s717qb42ywiqvdi18nybjadkivygfi2pbflip5rvphqfc8k8x";
        libraryHaskellDepends = [
          base bytestring io-streams lifted-base monad-loops mtl
          postgresql-simple
···
        testHaskellDepends = [ base bytestring hspec postgresql-simple ];
        description = "PostgreSQL Schema Migrations";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "postgresql-simple-named" = callPackage
+    ({ mkDerivation, base, bytestring, doctest, Glob, hspec, mtl
+     , postgresql-simple, resource-pool, text, transformers
+     }:
+     mkDerivation {
+       pname = "postgresql-simple-named";
+       version = "0.0.1.0";
+       sha256 = "1lp7bq7w3l127cb4js3gmmp8c9nvxabs64c200c73lqg5mw9fkfp";
+       libraryHaskellDepends = [
+         base bytestring mtl postgresql-simple text
+       ];
+       testHaskellDepends = [
+         base bytestring doctest Glob hspec postgresql-simple resource-pool
+         transformers
+       ];
+       description = "Implementation of named parameters for `postgresql-simple` library";
+       license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "postgresql-simple-opts" = callPackage
···
        pname = "pragmatic-show";
        version = "0.1.2.0";
        sha256 = "1nkwimmnk10p0pnv2hr3mxgfs1r2rjfhiaccmhd68a6279whp6p7";
+       revision = "1";
+       editedCabalFile = "17rs7ms62aisnk5wsdp67v3cgv5ph734iswv7137ibv339dlkl82";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [
          base tasty tasty-hunit tasty-quickcheck vector-space
···
     ({ mkDerivation, base, primitive }:
      mkDerivation {
        pname = "primitive-addr";
-       version = "0.1.0.1";
-       sha256 = "01gr75k2j60dgs711w1s9r201ndapqlwapznrvd3cm6r4rm3i54i";
+       version = "0.1.0.2";
+       sha256 = "06r1p56wm8rbjxnlaqbmc3rbsj1rsv5scwnh80lsn0xw56jc70a2";
        libraryHaskellDepends = [ base primitive ];
        description = "Addresses to unmanaged memory";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "product-profunctors";
        version = "0.10.0.0";
        sha256 = "0s0ssl2900r16992mgl0idkryg3l7psp8nljyg9brr7fqa3pd3dd";
-       revision = "1";
-       editedCabalFile = "17zi38fzg7yf9i5da2hlch6jw2qhmjcvs9wwkhyvra520605mlya";
+       revision = "2";
+       editedCabalFile = "0sarkc9sch60f5j1xjy30yrgycvmp5bqx1iynmlsfzdx7rvk5s29";
        libraryHaskellDepends = [
          base bifunctors contravariant profunctors tagged template-haskell
        ];
···
      }:
      mkDerivation {
        pname = "propellor";
-       version = "5.9.0";
-       sha256 = "1hgqq782qyqdnr86cx7xc063ksqyq37pwf58jz2g0rn3sk8qmv1i";
+       version = "5.9.1";
+       sha256 = "1v4cpj4kbmhl4xkxm7gxm2z9pqf6zmr4psawaxixvsav6xpxgphr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "purebred-email";
-       version = "0.1.0.1";
-       sha256 = "0igjid6rfg13bhgkm51np0ml2sfnkg5a6z3231mmiynkdja7l5zl";
+       version = "0.2.0.0";
+       sha256 = "1jjdia8qlwdibmfrqasyvm6qq01pxc9r66qmbyjmhz9bhdkqdd61";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, hmatrix, mtl, random-fu }:
      mkDerivation {
        pname = "random-fu-multivariate";
-       version = "0.1.2.0";
-       sha256 = "11hss3d1aa917g7w7k76zcakk82ras3046vb768yh5kayrb6a347";
-       revision = "2";
-       editedCabalFile = "13frafm1fdlgir64qsqy97158mv5chx98y23pdzdqiannf10w4by";
+       version = "0.1.2.1";
+       sha256 = "01r3jgjmhcj7wrc9ighwm0sbndsrz92l20gxh9p4rm2l90n0vxqc";
        libraryHaskellDepends = [ base hmatrix mtl random-fu ];
        testHaskellDepends = [ base ];
        description = "Multivariate distributions for random-fu";
···
        broken = true;
      }) {};
 
+  "range-set-list_0_1_3_1" = callPackage
+    ({ mkDerivation, base, containers, deepseq, hashable, tasty
+     , tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "range-set-list";
+       version = "0.1.3.1";
+       sha256 = "0m8c8qhpk9vaykqfy6gsv1csmvdclm27zv9l56ipv152k75xks0j";
+       libraryHaskellDepends = [ base containers deepseq hashable ];
+       testHaskellDepends = [
+         base containers deepseq hashable tasty tasty-quickcheck
+       ];
+       description = "Memory efficient sets with ranges of elements";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "range-space" = callPackage
     ({ mkDerivation, base, QuickCheck, semigroups, test-framework
      , test-framework-quickcheck2, time, vector-space
···
        ];
        description = "Notify Honeybadger about exceptions via a WAI middleware";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "ratel-wai_1_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, containers
+     , http-client, ratel, wai
+     }:
+     mkDerivation {
+       pname = "ratel-wai";
+       version = "1.1.0";
+       sha256 = "1wgmlcazfbz4y4q9k6367i76l8cal1qgqhqbh2p69ca365w9pf56";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive containers http-client ratel wai
+       ];
+       description = "Notify Honeybadger about exceptions via a WAI middleware";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "rating-chgk-info" = callPackage
···
      }) {};
 
   "readme-lhs" = callPackage
-    ({ mkDerivation, attoparsec, base, containers, filepath, foldl
-     , HUnit, optparse-applicative, protolude, tasty, tasty-hunit, text
+    ({ mkDerivation, base, containers, doctest, optparse-generic
+     , pandoc, pandoc-types, protolude, tasty, text
      }:
      mkDerivation {
        pname = "readme-lhs";
-       version = "0.1.0.0";
-       sha256 = "1pn0an37w4kgcn93a6qm0jxqsj882mhjwrnvl7hc5vp1960nqs6j";
+       version = "0.2.0";
+       sha256 = "0xwc2gqf23g87mi16miyi0nxy4wh33rki324biv3wh7xbpj03kpx";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ attoparsec base foldl protolude text ];
-       executableHaskellDepends = [
-         base containers filepath foldl optparse-applicative protolude text
+       libraryHaskellDepends = [
+         base containers pandoc pandoc-types protolude text
        ];
-       testHaskellDepends = [
-         base HUnit protolude tasty tasty-hunit text
+       executableHaskellDepends = [
+         base optparse-generic pandoc protolude
        ];
-       description = "See readme.lhs";
+       testHaskellDepends = [ base doctest protolude tasty ];
+       description = "See readme.md";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
···
      }:
      mkDerivation {
        pname = "red-black-record";
-       version = "2.0.2.2";
-       sha256 = "1afmqdgd0xhawjckjz318561zsr478a7jkpr20l7alic6zxnl4z9";
+       version = "2.0.4.0";
+       sha256 = "1wcg8a3aql1jmnfl7q5gzjgxl4z6780zgp8w10v3g52ilcdq4myn";
        libraryHaskellDepends = [ base sop-core ];
        testHaskellDepends = [
          aeson base bytestring doctest profunctors sop-core tasty
···
      }:
      mkDerivation {
        pname = "refined";
-       version = "0.4.2.1";
-       sha256 = "0p74hqmlx0ns8zjn689ngfjn4y5rvap5fza0p9mpx7107bskdf9d";
+       version = "0.4.2.2";
+       sha256 = "1gdfhmj8f1abxflxmqyfibz0hdaayr932f04vchygdvdb812av60";
        libraryHaskellDepends = [
          aeson base deepseq exceptions mtl prettyprinter QuickCheck
          template-haskell transformers
···
      }) {};
 
   "reflex" = callPackage
-    ({ mkDerivation, base, bifunctors, comonad, containers, criterion
-     , data-default, deepseq, dependent-map, dependent-sum, directory
-     , exception-transformers, filemanip, filepath, haskell-src-exts
-     , haskell-src-meta, hlint, lens, loch-th, MemoTrie, monad-control
-     , monoidal-containers, mtl, prim-uniq, primitive, process, random
-     , ref-tf, reflection, semigroupoids, semigroups, split, stm, syb
+    ({ mkDerivation, base, bifunctors, comonad, constraints-extras
+     , containers, criterion, data-default, deepseq, dependent-map
+     , dependent-sum, directory, exception-transformers, filemanip
+     , filepath, haskell-src-exts, haskell-src-meta, hlint, lens
+     , loch-th, MemoTrie, monad-control, monoidal-containers, mtl
+     , prim-uniq, primitive, process, profunctors, random, ref-tf
+     , reflection, semigroupoids, semigroups, split, stm, syb
      , template-haskell, these, time, transformers, transformers-compat
      , unbounded-delays, witherable
      }:
      mkDerivation {
        pname = "reflex";
-       version = "0.6.1";
-       sha256 = "1ggp2bpil2ig6rs45fn754kpqnp45lp069nc6ib4isj0dgzb9gpn";
+       version = "0.6.2.1";
+       sha256 = "0s8saim58bqqhg1nbrrdw2blnph7jrhqw97wxf73g4r1d8jacg3z";
        libraryHaskellDepends = [
-         base bifunctors comonad containers data-default dependent-map
-         dependent-sum exception-transformers haskell-src-exts
+         base bifunctors comonad constraints-extras containers data-default
+         dependent-map dependent-sum exception-transformers haskell-src-exts
          haskell-src-meta lens MemoTrie monad-control monoidal-containers
-         mtl prim-uniq primitive random ref-tf reflection semigroupoids
-         semigroups stm syb template-haskell these time transformers
-         transformers-compat unbounded-delays witherable
+         mtl prim-uniq primitive profunctors random ref-tf reflection
+         semigroupoids semigroups stm syb template-haskell these time
+         transformers transformers-compat unbounded-delays witherable
        ];
        testHaskellDepends = [
          base bifunctors containers deepseq dependent-map dependent-sum
···
        ];
        description = "Higher-order Functional Reactive Programming";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "reflex-animation" = callPackage
···
        executableHaskellDepends = [ base mtl reflex ];
        description = "A basic `reflex` host for backend work";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "reflex-dom" = callPackage
···
        sha256 = "084d03inyplx3n2zykaz2g7gskzs9hcjq8klhlnzpb1b6ahx5va8";
        libraryHaskellDepends = [ base hsp hsx2hs reform text ];
        description = "Add support for using HSP with Reform";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "reform-lucid" = callPackage
+    ({ mkDerivation, base, lucid, path-pieces, reform, text }:
+     mkDerivation {
+       pname = "reform-lucid";
+       version = "0.1.0.0";
+       sha256 = "1a3jfk0i87vqwxxlspzy44lf2i3bxxxy20pnbysczzf8i113y9zi";
+       libraryHaskellDepends = [ base lucid path-pieces reform text ];
+       description = "Add support for using lucid with Reform";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "registry-hedgehog";
-       version = "0.2.0.3";
-       sha256 = "138x33b9sficpy20dvcayf9isilv9crng2d46m2gh7ckidw94ghp";
+       version = "0.2.1.0";
+       sha256 = "1gx7grxy7p08bbvmxrhr3ciw9jg7isz3xsa2ha3s3pg4ifas4g59";
        libraryHaskellDepends = [
          base containers hedgehog mmorph multimap protolude registry tasty
          tasty-discover tasty-hedgehog tasty-th template-haskell text
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "relational-query_0_12_2_2" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, dlist
+     , names-th, persistable-record, product-isomorphic
+     , quickcheck-simple, sql-words, template-haskell, text
+     , th-reify-compat, time, time-locale-compat, transformers
+     }:
+     mkDerivation {
+       pname = "relational-query";
+       version = "0.12.2.2";
+       sha256 = "0768cw6c5chzdcwshjjniysik5d1yj7zvhwncqnn0wgy4gp6kzjv";
+       libraryHaskellDepends = [
+         array base bytestring containers dlist names-th persistable-record
+         product-isomorphic sql-words template-haskell text 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 = "Quick metrics to grow your app strong";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "ridley-extras" = callPackage
···
        testHaskellDepends = [ base ];
        description = "Handy metrics that don't belong to ridley";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "riemann" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "rio_0_1_10_0" = callPackage
+  "rio_0_1_11_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, deepseq, directory
      , exceptions, filepath, hashable, hspec, microlens, mtl, primitive
      , process, QuickCheck, text, time, typed-process, unix, unliftio
···
      }:
      mkDerivation {
        pname = "rio";
-       version = "0.1.10.0";
-       sha256 = "1jhiy139jl8rc8j4fwl76k1w8mrmmjszhsja7xcs8n2nxr13cb2g";
+       version = "0.1.11.0";
+       sha256 = "17p3zr1fncwqc1rz181mfbxi9dlyd2cd8xcxhnxm3fgnq6i9cj4l";
        libraryHaskellDepends = [
          base bytestring containers deepseq directory exceptions filepath
          hashable microlens mtl primitive process text time typed-process
···
        pname = "rio-prettyprint";
        version = "0.1.0.0";
        sha256 = "0n8ldc73i0954c6s8jh0hibxrisp84yh5pcxv3x3q0wg4v2xvr0m";
-       revision = "1";
-       editedCabalFile = "0ya7i766srm62p19idm7lwwfk01b81f8795q7jqqwl7rwk5rcdag";
+       revision = "2";
+       editedCabalFile = "1hvhjqy7kfk7fglx1rw8axscy0dfzqwd1564awnwdhvmf8silkkn";
        libraryHaskellDepends = [
          aeson annotated-wl-pprint ansi-terminal array base Cabal colour mtl
          path rio text
···
   "ron" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
      , containers, criterion, deepseq, hashable, integer-gmp, mtl
-     , template-haskell, text, time, unordered-containers
+     , scientific, template-haskell, text, time, unordered-containers
      }:
      mkDerivation {
        pname = "ron";
-       version = "0.6";
-       sha256 = "022ilxpk9axw41d1cmlgdsgc3c7ss6a0j6a1w10l81g56xlpi67z";
+       version = "0.7";
+       sha256 = "1bh4vdq9nwi5kwfa2qly1n0jfnphy17b8svd1k3jdzjfclwrjpgj";
        libraryHaskellDepends = [
          aeson attoparsec base binary bytestring containers hashable
-         integer-gmp mtl template-haskell text time unordered-containers
+         integer-gmp mtl scientific template-haskell text time
+         unordered-containers
        ];
        benchmarkHaskellDepends = [ base criterion deepseq integer-gmp ];
        description = "RON";
···
      }:
      mkDerivation {
        pname = "ron-rdt";
-       version = "0.6";
-       sha256 = "0npd4fh3flywfrpnwfsfpss4zbzd9jj9xsbpxlcc4hhjh45x1b6b";
+       version = "0.7";
+       sha256 = "1fcvsirzhwmkzcsdr0bhipqq7k7wsg1cjb6z3q4sjihcq9qp22gq";
        libraryHaskellDepends = [
          base containers Diff hashable integer-gmp mtl ron text time
          transformers unordered-containers
···
      }:
      mkDerivation {
        pname = "ron-schema";
-       version = "0.6";
-       sha256 = "07nn74vwx26flam7klwfvj4yz5mqh8d5flf5ps7wxxfn70z3g4yg";
+       version = "0.7";
+       sha256 = "12vnzmsj6vxvr26x7a9vvp025dxn9jlyi40hgpydpyg9dmjbs246";
        libraryHaskellDepends = [
          base bytestring containers hedn integer-gmp megaparsec mtl ron
          ron-rdt template-haskell text transformers
···
      }:
      mkDerivation {
        pname = "ron-storage";
-       version = "0.7";
-       sha256 = "0wqvbnylz2wx85c7qfqzima3axif6r65vc0iwl8lrmxpif2zs41c";
+       version = "0.8";
+       sha256 = "1326r8x3m4x1ylf32x66h9s6y7z4hwrwah33kkshj656f3f4bnds";
        libraryHaskellDepends = [
          base bytestring containers directory filepath integer-gmp mtl
          network-info ron ron-rdt stm text transformers
···
      }:
      mkDerivation {
        pname = "ruby-marshal";
-       version = "0.1.2";
-       sha256 = "13s017sqim92yz9r3x8zc4by1hksncikavsn12kf42vv58k95g1p";
+       version = "0.1.3";
+       sha256 = "0syjd9fmp55cfkq1kb78pvx0vg9dk43s5w4q2a8ndd1fkg194jwx";
        libraryHaskellDepends = [
          base bytestring cereal containers mtl string-conv vector
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "salak_0_2_9_3" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers
-     , data-default, directory, filepath, hspec, menshen, mtl, pqueue
-     , QuickCheck, scientific, text, time, unliftio-core
+  "salak_0_3_3" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, data-default
+     , directory, exceptions, filepath, hashable, heaps, hspec, menshen
+     , mtl, QuickCheck, random, scientific, text, time, unliftio-core
+     , unordered-containers
      }:
      mkDerivation {
        pname = "salak";
-       version = "0.2.9.3";
-       sha256 = "0y1p2cf8bpglqf20a16d2h5xfknzz6wcdgwv6mamh24mdqv0c3rn";
+       version = "0.3.3";
+       sha256 = "1jq9vngi03wqcvfb1r9ndg4w1vipgbhbzdyybkpj4hmc074l1079";
        libraryHaskellDepends = [
-         attoparsec base bytestring containers data-default directory
-         filepath menshen mtl pqueue scientific text time unliftio-core
+         attoparsec base bytestring data-default directory exceptions
+         filepath hashable heaps menshen mtl scientific text time
+         unliftio-core unordered-containers
        ];
        testHaskellDepends = [
-         attoparsec base bytestring containers data-default directory
-         filepath hspec menshen mtl pqueue QuickCheck scientific text time
-         unliftio-core
+         attoparsec base bytestring data-default directory exceptions
+         filepath hashable heaps hspec menshen mtl QuickCheck random
+         scientific text time unliftio-core unordered-containers
        ];
-       description = "Configuration Loader";
-       license = stdenv.lib.licenses.bsd3;
+       description = "Configuration (re)Loader and Parser";
+       license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "salak-toml" = callPackage
-    ({ mkDerivation, base, hspec, mtl, QuickCheck, salak, text, time
-     , tomland, unordered-containers
+    ({ mkDerivation, base, exceptions, hspec, mtl, QuickCheck, salak
+     , text, time, tomland, unordered-containers
      }:
      mkDerivation {
        pname = "salak-toml";
-       version = "0.2.9.3";
-       sha256 = "1hb5ddm7a9acwri730w50p14vyk6z8q1wnx2b87386d80am5mbpy";
+       version = "0.3.3";
+       sha256 = "0961xwj928map27az5qlp86wxg5jj6kq9cxqhbmcyl7m1cic91dy";
        libraryHaskellDepends = [
-         base mtl salak text time tomland unordered-containers
+         base salak text time tomland unordered-containers
        ];
        testHaskellDepends = [
-         base hspec mtl QuickCheck salak text time tomland
+         base exceptions hspec mtl QuickCheck salak text time tomland
          unordered-containers
        ];
        description = "Configuration Loader for toml";
-       license = stdenv.lib.licenses.bsd3;
+       license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
 
   "salak-yaml" = callPackage
-    ({ mkDerivation, base, conduit, hspec, libyaml, mtl, QuickCheck
-     , salak, text
+    ({ mkDerivation, base, conduit, exceptions, hspec, libyaml, mtl
+     , QuickCheck, salak, text
      }:
      mkDerivation {
        pname = "salak-yaml";
-       version = "0.2.9.3";
-       sha256 = "0jjmw923zvm349q318iw7y5lfqhbr85xgp6ai3xx5w5d4mcb2f32";
+       version = "0.3.3";
+       sha256 = "038pfna1jijw6vf8b89ql4f4987s60lpj90nlny66wxkj4b2nbrq";
        libraryHaskellDepends = [ base conduit libyaml salak text ];
        testHaskellDepends = [
-         base conduit hspec libyaml mtl QuickCheck salak text
+         base conduit exceptions hspec libyaml mtl QuickCheck salak text
        ];
        description = "Configuration Loader for yaml";
-       license = stdenv.lib.licenses.bsd3;
+       license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "scidb-hquery";
-       version = "2.8.0.432";
-       sha256 = "0swjsgf84kwkzv7nwrnrzlpxbhdvi3i5pnnjrlgql9x4c30bqw6i";
+       version = "2.8.0.434";
+       sha256 = "0q994ac1krcw312nklxxjr9d4r231s50lb2crbpph1swv6h8jwrq";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal filepath ];
···
        ];
        description = "Fay integration for Scotty";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "scotty-form" = callPackage
+    ({ mkDerivation, base, ditto, ditto-lucid, lucid, scotty, text }:
+     mkDerivation {
+       pname = "scotty-form";
+       version = "0.1.0.0";
+       sha256 = "0ks11rav9x52lq27mr12qlygg6yl9wl87fqa28jbz084fwn97w44";
+       libraryHaskellDepends = [
+         base ditto ditto-lucid lucid scotty text
+       ];
+       description = "Html form validation using `ditto`";
+       license = stdenv.lib.licenses.gpl2;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "sdr";
-       version = "0.1.0.11";
-       sha256 = "0gkf7ql1a40vpb4qaivcyygvlykp4whljmhp2jy37bk56zr45yvv";
+       version = "0.1.0.12";
+       sha256 = "0nikrpcyb5mihc70cfvxy24bl80jjnabc8dc8y056yx54759jkk8";
        libraryHaskellDepends = [
          array base bytestring cairo cereal Chart Chart-cairo colour
          containers Decimal dynamic-graph fftwRaw GLFW-b mwc-random OpenGL
···
        pname = "serialise";
        version = "0.2.1.0";
        sha256 = "19ary6ivzk8z7wcxhm860qmh7pwqj0qjqzav1h42y85l608zqgh4";
+       revision = "1";
+       editedCabalFile = "1rknhad1i8bpknsnphmcmb6dnb48c2p2c13ia2qqch3hkhsvfpr6";
        libraryHaskellDepends = [
          array base bytestring cborg containers ghc-prim half hashable
          primitive text time unordered-containers vector
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "servant_0_16_1" = callPackage
+  "servant_0_16_2" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base-compat, bifunctors
      , bytestring, Cabal, cabal-doctest, case-insensitive, deepseq
      , doctest, hspec, hspec-discover, http-api-data, http-media
···
      }:
      mkDerivation {
        pname = "servant";
-       version = "0.16.1";
-       sha256 = "1v63b3ng1zck4jw79ijjv4vvsm8w1c8vz4c0dd8sklpkcrfbpxam";
+       version = "0.16.2";
+       sha256 = "0yzl1yklbbymlh8jdc4ncrdxkalx2z349v4msbd6wxxrxfkxbz6n";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson attoparsec base base-compat bifunctors bytestring
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "servant-server_0_16_1" = callPackage
+  "servant-server_0_16_2" = callPackage
     ({ mkDerivation, aeson, base, base-compat, base64-bytestring
      , bytestring, Cabal, cabal-doctest, containers, directory, doctest
      , exceptions, filepath, hspec, hspec-discover, hspec-wai
···
      }:
      mkDerivation {
        pname = "servant-server";
-       version = "0.16.1";
-       sha256 = "1zkx6ipz4ay64jdvqxhhrq2sfxj6d6ma8z4cxwpascnawhjqjpq7";
+       version = "0.16.2";
+       sha256 = "1l4kgjg5z775bi76hy7cb70qwvmkai4rxqkgp0ildsjgsvf8qb80";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "silently_1_2_5_1" = callPackage
+    ({ mkDerivation, base, deepseq, directory, nanospec, temporary }:
+     mkDerivation {
+       pname = "silently";
+       version = "1.2.5.1";
+       sha256 = "1lgs1gsr5dp0x21diqn4l03fxgai2kgdmj85gqp0iz3zykvbmjbz";
+       libraryHaskellDepends = [ base deepseq directory ];
+       testHaskellDepends = [ base deepseq directory nanospec temporary ];
+       description = "Prevent or capture writing to stdout and other handles";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "silvi" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, chronos, http-types
      , ip, quantification, savage, text
···
      }:
      mkDerivation {
        pname = "simple";
-       version = "0.11.2";
-       sha256 = "05069qjgzm4j22p0q6i75qpsvzpw52b7bh2x2b6jcxnlvqp6flzg";
+       version = "0.11.3";
+       sha256 = "0qifp6wacsmykb09ddx03yv4pbk7c1rhs16jjlfafm2wc2025rac";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        libraryHaskellDepends = [ base Cabal directory filepath ];
        description = "Cabal file wrapper library";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "simple-cabal_0_0_0_1" = callPackage
+    ({ mkDerivation, base, Cabal, directory, filepath }:
+     mkDerivation {
+       pname = "simple-cabal";
+       version = "0.0.0.1";
+       sha256 = "17v22v9sb8z2jbr76vv577hxcvypfkpmji2k8yzwd2kxjssxpjrn";
+       libraryHaskellDepends = [ base Cabal directory filepath ];
+       description = "Cabal file wrapper library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "simple-cmd" = callPackage
···
      }:
      mkDerivation {
        pname = "simple-templates";
-       version = "0.8.0.1";
-       sha256 = "13na1f29fvc0j452kh0a3fjig3fq4qbklcpdv6bm1fr0cf8hzq98";
+       version = "0.9.0.0";
+       sha256 = "09s81syr45dvrqski4gz96ynmv8gb3zwyy4n6a7frv49z843phda";
        libraryHaskellDepends = [
          aeson attoparsec base scientific text unordered-containers vector
        ];
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "skylighting_0_8_1_1" = callPackage
+  "skylighting_0_8_2" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
      , base64-bytestring, binary, blaze-html, bytestring
      , case-insensitive, colour, containers, directory, filepath, hxt
···
      }:
      mkDerivation {
        pname = "skylighting";
-       version = "0.8.1.1";
-       sha256 = "0q1zkb053szbgx3lqpmllxas0krb9m425qi0aplffhdqwmd05w8w";
+       version = "0.8.2";
+       sha256 = "0a81hd4f0xlc8as5lh454gkbyxndaxyj7lblkfk92j173nyx69cz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "skylighting-core_0_8_1_1" = callPackage
+  "skylighting-core_0_8_2" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
      , base64-bytestring, binary, blaze-html, bytestring
      , case-insensitive, colour, containers, criterion, Diff, directory
···
      }:
      mkDerivation {
        pname = "skylighting-core";
-       version = "0.8.1.1";
-       sha256 = "1klk9jlnyz5ciz2gm1dx5mh85nkvz6y1xsflvyf45c2gw9grc2km";
+       version = "0.8.2";
+       sha256 = "1nd11170r7xwv0hy21bx9nz7173ijbqkh7r8504ixjkwckgr2zs0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "small-bytearray-builder" = callPackage
-    ({ mkDerivation, base, byteslice, primitive, primitive-offset
-     , QuickCheck, run-st, tasty, tasty-quickcheck, vector
+    ({ mkDerivation, base, byteslice, bytestring, gauge, primitive
+     , primitive-offset, QuickCheck, run-st, tasty, tasty-quickcheck
+     , vector
      }:
      mkDerivation {
        pname = "small-bytearray-builder";
-       version = "0.1.0.0";
-       sha256 = "1dsjvgl15wbja1fzm1sawqavvijkmaqidfaqk9qgp42kifhh0hzh";
+       version = "0.1.1.0";
+       sha256 = "1i3b77mczfy9f0gp5ckqln1vdhnqflz8lajfiygx5spxf9kraf9d";
        libraryHaskellDepends = [
          base byteslice primitive primitive-offset run-st vector
        ];
        testHaskellDepends = [
-         base byteslice primitive QuickCheck tasty tasty-quickcheck vector
+         base byteslice bytestring primitive QuickCheck tasty
+         tasty-quickcheck vector
        ];
+       benchmarkHaskellDepends = [ base gauge primitive ];
        description = "Serialize to a small byte arrays";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        pname = "snaplet-customauth";
        version = "0.1.2";
        sha256 = "0y1a8c9j1q1pzby5v4ajnafm6dr9fvxvvkiynvscyjsf73gp2myb";
+       revision = "1";
+       editedCabalFile = "1dh8vmrnndg06l5yr3fbmxlzf164nvcy923mafc624bxcr6iip9f";
        libraryHaskellDepends = [
          aeson base base64-bytestring binary binary-orphans bytestring
          configurator containers errors heist hoauth2 http-client
···
      }:
      mkDerivation {
        pname = "sockets";
-       version = "0.4.0.0";
-       sha256 = "0xv8341kvy6br88lj4g17hqci9sn8qbm063iv69gmfbyp5x7fs9d";
+       version = "0.5.0.0";
+       sha256 = "0pxrdxmiqyp5xs24sp22b4rldhzm1rahkdq5lc24m30g4p609xa3";
+       revision = "1";
+       editedCabalFile = "1ji60m0wj3jwdfwdjaxzic41rwdnq72m9xspn64f66c872lx137d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        testHaskellDepends = [
          async base byteslice bytestring ip primitive primitive-addr
-         primitive-unlifted tasty tasty-hunit
+         primitive-unlifted stm tasty tasty-hunit
        ];
        benchmarkHaskellDepends = [
          base byteslice bytestring entropy ip primitive
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "sortee" = callPackage
+    ({ mkDerivation, base, hspec, HUnit, QuickCheck }:
+     mkDerivation {
+       pname = "sortee";
+       version = "0.1.0.1";
+       sha256 = "0lnjxryiqnkmsdqjam37ld1xqk50l3qh6lmmpsw5fnw48c8hlyzs";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec HUnit QuickCheck ];
+       description = "Generate string for sort key";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "sorting" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "spatial-rotations";
        version = "0.1.0.1";
        sha256 = "02nysw4dbg5l37j83kdybxkrdzgjxn20h3lknnphwz0hr0n489ii";
-       revision = "2";
-       editedCabalFile = "174y0jgf9bxqsc895f984q0gwn981sxdxmnwd3c25jp03iidc6c4";
+       revision = "3";
+       editedCabalFile = "03kjhr51w600cnm1jgdc9nbm9ay66fxq93z7r6xgph1a4dmcjvg4";
        libraryHaskellDepends = [
          base linear manifolds-core vector-space
        ];
···
      }:
      mkDerivation {
        pname = "spectral-clustering";
-       version = "0.3.0.2";
-       sha256 = "1jxjqdyjj8ajv7qb3qldaqh2mr00fg51yp4fiqi5d3bd4b4isga8";
+       version = "0.3.1.0";
+       sha256 = "140njrq73nalkm7dp9vyk3hz027jj0ppgjqdr3qcz93a9lkzdsyh";
        libraryHaskellDepends = [
          base clustering containers eigen hmatrix hmatrix-svdlibc mwc-random
          safe sparse-linear-algebra statistics vector
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "splitmix_0_0_3" = callPackage
+    ({ mkDerivation, async, base, base-compat-batteries, bytestring
+     , clock, containers, criterion, deepseq, HUnit, process, random
+     , tf-random, time, vector
+     }:
+     mkDerivation {
+       pname = "splitmix";
+       version = "0.0.3";
+       sha256 = "1k0amgkz7rvyz3lnw7m786ilnr1cibwhx9sc4qynq329gxan5r7w";
+       libraryHaskellDepends = [ base deepseq random time ];
+       testHaskellDepends = [
+         async base base-compat-batteries bytestring deepseq HUnit process
+         random tf-random vector
+       ];
+       benchmarkHaskellDepends = [
+         base clock containers criterion random tf-random
+       ];
+       description = "Fast Splittable PRNG";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "splitter" = callPackage
     ({ mkDerivation, base, directory, filepath, parsec, range }:
      mkDerivation {
···
      , http-client, http-client-tls, http-conduit, http-download
      , http-types, memory, microlens, mintty, mono-traversable, mtl
      , mustache, neat-interpolation, network-uri, open-browser
-     , optparse-applicative, pantry-tmp, path, path-io, persistent
+     , optparse-applicative, pantry, path, path-io, persistent
      , persistent-sqlite, persistent-template, pretty, primitive
      , process, project-template, QuickCheck, raw-strings-qq
      , regex-applicative-text, resource-pool, resourcet, retry, rio
···
      }:
      mkDerivation {
        pname = "stack";
-       version = "2.1.1.1";
-       sha256 = "1qqy0hkcvr4nblpknwljc71hck8ccpdiqxbxhj5mjwp9ybvag1j2";
-       revision = "2";
-       editedCabalFile = "0c2vqmw6rvq4jspmc1h1d33bdzmm63svrax1q5r9g70lvjfi7ax8";
+       version = "2.1.3.1";
+       sha256 = "1q2nagnc24fvyj3hwnpgyp3rqhxswhscyw4pw2dazqx34ad3d0zr";
        configureFlags = [
          "-fdisable-git-info" "-fhide-dependency-versions"
          "-fsupported-build"
···
          http-client http-client-tls http-conduit http-download http-types
          memory microlens mintty mono-traversable mtl mustache
          neat-interpolation network-uri open-browser optparse-applicative
-         pantry-tmp path path-io persistent persistent-sqlite
+         pantry path path-io persistent persistent-sqlite
          persistent-template pretty primitive process project-template
          regex-applicative-text resource-pool resourcet retry rio
          rio-prettyprint semigroups split stm streaming-commons tar
···
          http-client http-client-tls http-conduit http-download http-types
          memory microlens mintty mono-traversable mtl mustache
          neat-interpolation network-uri open-browser optparse-applicative
-         pantry-tmp path path-io persistent persistent-sqlite
+         pantry path path-io persistent persistent-sqlite
          persistent-template pretty primitive process project-template
          regex-applicative-text resource-pool resourcet retry rio
          rio-prettyprint semigroups split stm streaming-commons tar
···
          hspec http-client http-client-tls http-conduit http-download
          http-types memory microlens mintty mono-traversable mtl mustache
          neat-interpolation network-uri open-browser optparse-applicative
-         pantry-tmp path path-io persistent persistent-sqlite
+         pantry path path-io persistent persistent-sqlite
          persistent-template pretty primitive process project-template
          QuickCheck raw-strings-qq regex-applicative-text resource-pool
          resourcet retry rio rio-prettyprint semigroups smallcheck split stm
···
      }:
      mkDerivation {
        pname = "stack2cabal";
-       version = "1.0.2";
-       sha256 = "0zdyjf55zda465ai6bjp13a4f4khgz59smmaa2nlbbrjknlb1kbl";
+       version = "1.0.3";
+       sha256 = "1bmghzb866p3225ai3w4xxy3s2qic3vr4srcx7xb113qjvmadran";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "stackage-to-hackage";
-       version = "1.1.0";
-       sha256 = "165g5vyxck8hh2523v4h0cwjl3yvp4wwzlsdrs9wvg9ca3ij0v85";
+       version = "1.1.1";
+       sha256 = "10zd3wqla54mfnwv65gklvmglhcpzhanqfka0l0ilnbkqlgx4acm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        libraryHaskellDepends = [ array base bytestring containers ];
        description = "A wrapper around Sean Barrett's TrueType rasterizer library";
        license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
+  "stc-lang" = callPackage
+    ({ mkDerivation, abstract-par, aeson, base, BoundedChan, bytestring
+     , clock, deepseq, ghc-prim, hashable, hashtables, hedis, HUnit
+     , hw-kafka-client, microlens, microlens-aeson, monad-par
+     , monad-par-extras, mtl, random, test-framework
+     , test-framework-hunit, text, time, transformers, uuid-types
+     , vector, yaml
+     }:
+     mkDerivation {
+       pname = "stc-lang";
+       version = "1.0.0";
+       sha256 = "1x11q696f3598g3ph3shiia0xwxqjaydp27inmfqz01p891xhj5w";
+       revision = "1";
+       editedCabalFile = "1fjkr2k0j2463vifmaqm6d8pk3r66wrmf74g8lypgf9p4vbsv53m";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         abstract-par base BoundedChan bytestring deepseq microlens
+         monad-par monad-par-extras mtl transformers
+       ];
+       executableHaskellDepends = [
+         aeson base BoundedChan bytestring clock deepseq hashable hashtables
+         hedis hw-kafka-client microlens microlens-aeson mtl random text
+         transformers uuid-types vector yaml
+       ];
+       testHaskellDepends = [
+         base deepseq ghc-prim HUnit microlens mtl test-framework
+         test-framework-hunit time transformers
+       ];
+       description = "A library for implicit, monadic dataflow parallelism";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "std" = callPackage
···
      }) {};
 
   "stratux" = callPackage
-  "mega-sdist" = callPackage
-     , stratux-http, stratux-types, stratux-websockets, template-haskell
+    ({ mkDerivation, base, stratux-http, stratux-types
+     , stratux-websockets
      }:
      mkDerivation {
        pname = "stratux";
-       version = "0.0.9";
-       sha256 = "17jy7svf74k3r87p8xlp0hi9z95f5npmnn28jlwx4rb68dn63aly";
+       version = "0.0.10";
+       sha256 = "0km05c7i6yxlxy4fa39rrll1xmf5yzb6vk1b8s8rmh19520dzb07";
        libraryHaskellDepends = [
          base stratux-http stratux-types stratux-websockets
        ];
-       testHaskellDepends = [
-         base directory doctest filepath QuickCheck template-haskell
-       ];
        description = "A library for stratux";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
 
+  "stratux-demo" = callPackage
+    ({ mkDerivation, base, lens, network-uri, optparse-applicative
+     , stratux, text, time, transformers
+     }:
+     mkDerivation {
+       pname = "stratux-demo";
+       version = "0.0.12";
+       sha256 = "0rarr1z6rk6idjyxzb0053p90rpixqwc767bslcm6dvj9rxbgsvp";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base lens network-uri optparse-applicative stratux text time
+         transformers
+       ];
+       executableHaskellDepends = [
+         base lens network-uri optparse-applicative stratux text time
+         transformers
+       ];
+       description = "A demonstration of the stratux library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "stratux-http" = callPackage
-    ({ mkDerivation, aeson, base, directory, doctest, either, filepath
-     , HTTP, network-uri, QuickCheck, stratux-types, template-haskell
-     , utf8-string
+    ({ mkDerivation, aeson, base, HTTP, network-uri, stratux-types
+     , transformers, utf8-string
      }:
      mkDerivation {
        pname = "stratux-http";
-       version = "0.0.9";
-       sha256 = "121pansnd8pdhv9ki2qdav93cwldmnxnykjldhbkb2bkyr0skdyb";
-       revision = "1";
-       editedCabalFile = "0paq3zs9c39dcjxxyz975q4nccmgdxxay839wa60gka75hix34gs";
+       version = "0.0.11";
+       sha256 = "056fz3fs1giwlh9yfj462p0bg98gzikbqvkkwcyrmyqpxjsala15";
        libraryHaskellDepends = [
-         aeson base either HTTP network-uri stratux-types utf8-string
-       ];
-       testHaskellDepends = [
-         base directory doctest filepath QuickCheck template-haskell
+         aeson base HTTP network-uri stratux-types transformers utf8-string
        ];
        description = "A library for using HTTP with stratux";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "stratux-types" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, directory, doctest
-     , filepath, lens, QuickCheck, scientific, template-haskell, text
+    ({ mkDerivation, aeson, base, bytestring, lens, scientific, text
      , time
      }:
      mkDerivation {
        pname = "stratux-types";
-       version = "0.0.9";
-       sha256 = "06d4qagcmzch25zkxpnvw04h5aav5wbdrfyi6xvzvndj12hvayza";
+       version = "0.0.11";
+       sha256 = "0ps9y9rfjk5xzikkl4rsv203rfqc1yqa8alp5hx37lqgcnymw4hy";
        libraryHaskellDepends = [
          aeson base bytestring lens scientific text time
        ];
-       testHaskellDepends = [
-         base directory doctest filepath QuickCheck template-haskell
-       ];
        description = "A library for reading JSON output from stratux";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }) {};
 
   "stratux-websockets" = callPackage
-    ({ mkDerivation, aeson, base, directory, doctest, either, filepath
-     , network, QuickCheck, stratux-types, template-haskell, text
+    ({ mkDerivation, aeson, base, either, network, stratux-types, text
      , transformers, websockets
      }:
      mkDerivation {
        pname = "stratux-websockets";
-       version = "0.0.9";
-       sha256 = "0076n4i250frv71w9sysw935g5aq0py8shwaqrhjrv4jp6mb2k3q";
-       revision = "1";
-       editedCabalFile = "0863p5spgs68q6ddp3v9azm7x01wky1480yp3rrjxpkgay1ha4db";
+       version = "0.0.11";
+       sha256 = "0602y8h37zplp1g0fmdim1f8pmdz713jydc4qsh6ii3x58i8klj5";
        libraryHaskellDepends = [
          aeson base either network stratux-types text transformers
          websockets
-       ];
-       testHaskellDepends = [
-         base directory doctest filepath QuickCheck template-haskell
        ];
        description = "A library for using websockets with stratux";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "summoner";
        version = "1.3.0.1";
        sha256 = "1m08n2ip9rjx06mcwcv636ncicmpxcmhx82i3p4yc5vylibxr57s";
-       revision = "3";
-       editedCabalFile = "0galzkk5y41akmy12vfk8zh5pm9pyv4a5034qpfcxm7ix0s2ivms";
+       revision = "4";
+       editedCabalFile = "1vjk95n2wqybigy8p55gs7qkiv5v1lwf8qmri1f9bk29599sh74k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "symantic";
-       version = "6.3.3.20190614";
-       sha256 = "1l0a82r1fx6ai5csjaqiha8gngb1pay1cmj947619xy36iwng3pc";
+       version = "6.3.4.20190712";
+       sha256 = "0khx7ddr9cdwyqz22xai8vmjn37c3w9gf4mlzil8lqvdf2cwk6wk";
        libraryHaskellDepends = [
          base containers mono-traversable symantic-document symantic-grammar
          text transformers
···
      }) {};
 
   "symantic-cli" = callPackage
-    ({ mkDerivation, base, containers, megaparsec, symantic-document
-     , text, transformers
+    ({ mkDerivation, base, bytestring, containers, megaparsec
+     , symantic-document, text, transformers
      }:
      mkDerivation {
        pname = "symantic-cli";
-       version = "2.2.4.20190701";
-       sha256 = "0qkfjhva0mrmirc4md82r5f738i6af4whlyqnxmksqz0jwa9r5nv";
+       version = "2.4.0.20190719";
+       sha256 = "0ca3c309wxby99sy3xa96i04q2r7wxcgk4amy8z86xaz1r78a60d";
        libraryHaskellDepends = [
-         base containers megaparsec symantic-document text transformers
+         base bytestring containers megaparsec symantic-document text
+         transformers
        ];
        description = "Symantics for parsing and documenting a CLI";
        license = stdenv.lib.licenses.gpl3;
···
      }:
      mkDerivation {
        pname = "symantic-document";
-       version = "1.2.3.20190628";
-       sha256 = "0ahbhksiyinfsbgb2xhikckly8m5g2lfads5cjk7mbi27zn9y2v8";
+       version = "1.5.0.20190711";
+       sha256 = "01vza9k4ic6xwgj4jqihcfm5a5q8n6svi1988v851pi40dg8m03s";
        libraryHaskellDepends = [ ansi-terminal base text transformers ];
        testHaskellDepends = [
          base containers tasty tasty-hunit text transformers
···
        broken = true;
      }) {};
 
+  "symantic-xml" = callPackage
+    ({ mkDerivation, base, bytestring, containers, data-default-class
+     , deepseq, filepath, hashable, hxt-charproperties, megaparsec, safe
+     , tasty, tasty-golden, text, transformers, treeseq
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "symantic-xml";
+       version = "1.0.0.20190223";
+       sha256 = "0mqx0ysp9c4zzljjgl0w68k5r8qgv2h35cfq0mqvijcjq5dgiflp";
+       libraryHaskellDepends = [
+         base bytestring containers data-default-class filepath hashable
+         hxt-charproperties megaparsec safe text transformers treeseq
+         unordered-containers
+       ];
+       testHaskellDepends = [
+         base bytestring containers data-default-class deepseq filepath
+         hashable megaparsec tasty tasty-golden text transformers treeseq
+       ];
+       description = "Library for reading, validating and writing a subset of the XML format";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "symbol" = callPackage
     ({ mkDerivation, base, containers, deepseq }:
      mkDerivation {
···
        editedCabalFile = "0jdbaap11pkgb6m98v57k7qnx62pqxy7pa2i7293ywa4q305qgm1";
        libraryHaskellDepends = [ base containers deepseq ];
        description = "A 'Symbol' type for fast symbol comparison";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "symbolic-link" = callPackage
+    ({ mkDerivation, base, directory, unix, yaml }:
+     mkDerivation {
+       pname = "symbolic-link";
+       version = "0.1.0.2";
+       sha256 = "02v0ry474xkpacbav6s3781xiczkhbx5rzks9ad5pj2y16z59pr7";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base directory unix ];
+       executableHaskellDepends = [ base directory unix yaml ];
+       description = "Symlink tools";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        pname = "tai";
        version = "0";
        sha256 = "1kp7m9mhawi2fbdsir4kg9z6hbmlw4kmp3kjvlk4qkhvckgl3pxw";
+       revision = "1";
+       editedCabalFile = "0m95bx120pjigxncbdb28y3cv4d6x05vgpjgny86vk0lkslk130y";
        libraryHaskellDepends = [
          base clock lens mtl parsers time trifecta wreq
        ];
···
        pname = "tart";
        version = "0.1.2";
        sha256 = "1ik86xbai9513gr9k60m55xf5pj5bdw3wbjc0gd260j9k9j4p73k";
+       revision = "1";
+       editedCabalFile = "04xkrc0xfbx2kk6f8b41zf611s4k848ahczbbs85pd9lqqpkbhzj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "tasty-silver_3_1_13" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
+     , deepseq, directory, filepath, mtl, optparse-applicative, process
+     , process-extras, regex-tdfa, semigroups, stm, tagged, tasty
+     , tasty-hunit, temporary, text, transformers
+     }:
+     mkDerivation {
+       pname = "tasty-silver";
+       version = "3.1.13";
+       sha256 = "1sd9xgjcvlnw338dn5rcy5la7gw15yvg4xl85ym7aav5fr97apfs";
+       libraryHaskellDepends = [
+         ansi-terminal async base bytestring containers deepseq directory
+         filepath mtl optparse-applicative process process-extras regex-tdfa
+         semigroups stm tagged tasty temporary text
+       ];
+       testHaskellDepends = [
+         base directory filepath process tasty tasty-hunit temporary
+         transformers
+       ];
+       description = "A fancy test runner, including support for golden tests";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "tasty-smallcheck" = callPackage
     ({ mkDerivation, async, base, smallcheck, tagged, tasty }:
      mkDerivation {
···
        testHaskellDepends = [ base tasty-hunit ];
        description = "Automatic tasty test case discovery using TH";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "tasty-tmux" = callPackage
+    ({ mkDerivation, base, bytestring, mtl, regex-posix, tasty
+     , tasty-hunit, text, typed-process
+     }:
+     mkDerivation {
+       pname = "tasty-tmux";
+       version = "0.1.0.0";
+       sha256 = "1k7xc2fvfjrv48hml1jlhjrdrnb9sjaar7xrbwbj1275s09b51h8";
+       libraryHaskellDepends = [
+         base bytestring mtl regex-posix tasty tasty-hunit text
+         typed-process
+       ];
+       description = "Terminal user acceptance testing (UAT) via tmux";
+       license = stdenv.lib.licenses.agpl3;
      }) {};
 
   "tasty-travis" = callPackage
···
        ];
        description = "Terminal emulator configurable in Haskell";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) gtk3; vte_291 = pkgs.vte;};
 
   "termplot" = callPackage
···
      }:
      mkDerivation {
        pname = "text-cp437";
-       version = "0.2.1";
-       sha256 = "1fzsb341yr1jiv9wflr35ra1z1cd41wmyp0y5dv2p0fq10kxcfgs";
+       version = "0.2.2";
+       sha256 = "1lv1nhkrwdrs3ji7x2qv1r33dipgchr1fl2znmmkhxksbhlwi0x9";
        libraryHaskellDepends = [ base bytestring text ];
        testHaskellDepends = [
          base bytestring QuickCheck quickcheck-text text
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "text-short_0_1_3" = callPackage
+    ({ mkDerivation, base, binary, bytestring, deepseq, ghc-prim
+     , hashable, quickcheck-instances, tasty, tasty-hunit
+     , tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "text-short";
+       version = "0.1.3";
+       sha256 = "0xyrxlb602z8bc9sr2y1fag0x56a20yj5qrkvy7iwc6hnznrynxz";
+       libraryHaskellDepends = [
+         base binary bytestring deepseq ghc-prim hashable text
+       ];
+       testHaskellDepends = [
+         base binary quickcheck-instances tasty tasty-hunit tasty-quickcheck
+         text
+       ];
+       description = "Memory-efficient representation of Unicode text strings";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "text-show" = callPackage
     ({ mkDerivation, array, base, base-compat-batteries, base-orphans
      , bifunctors, bytestring, bytestring-builder, containers
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
+  "th-test-utils" = callPackage
+    ({ mkDerivation, base, tasty, tasty-hunit, template-haskell
+     , transformers
+     }:
+     mkDerivation {
+       pname = "th-test-utils";
+       version = "1.0.0";
+       sha256 = "1kpkf6h0vr06z7iphkcjva9x28mfjg967hrih4im527g9vw5mdq6";
+       libraryHaskellDepends = [ base template-haskell transformers ];
+       testHaskellDepends = [
+         base tasty tasty-hunit template-haskell transformers
+       ];
+       description = "Utility functions for testing Template Haskell code";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "th-to-exp" = callPackage
     ({ mkDerivation, base, hspec, template-haskell }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "these_1" = callPackage
+  "these_1_0_1" = callPackage
     ({ mkDerivation, aeson, assoc, base, base-compat, binary, deepseq
      , hashable, QuickCheck, semigroupoids, unordered-containers
      }:
      mkDerivation {
        pname = "these";
-       version = "1";
-       sha256 = "01pnibkkzbsdiry4w018img92ja2sqwjigpw53q12mfnabvsgvxn";
+       version = "1.0.1";
+       sha256 = "1k0pi65g7cm9hzdw6my6bzz2zvddkmj1qs45ymqmi316bpiixk3r";
        libraryHaskellDepends = [
          aeson assoc base base-compat binary deepseq hashable QuickCheck
          semigroupoids unordered-containers
···
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
+  "tidal_1_3_0" = callPackage
+    ({ mkDerivation, base, bifunctors, bytestring, clock, colour
+     , containers, criterion, deepseq, hosc, microspec, mwc-random
+     , network, parsec, text, transformers, vector, weigh
+     }:
+     mkDerivation {
+       pname = "tidal";
+       version = "1.3.0";
+       sha256 = "0zd9z0nc600b1zw0c1bpl5b3ik1dcspv5kd72p3if70g81x56d8l";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bifunctors bytestring clock colour containers deepseq hosc
+         mwc-random network parsec text transformers vector
+       ];
+       testHaskellDepends = [ base containers microspec parsec ];
+       benchmarkHaskellDepends = [ base criterion weigh ];
+       description = "Pattern language for improvised music";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "tidal-midi" = callPackage
     ({ mkDerivation, base, containers, PortMidi, tidal, time
      , transformers
···
      }) {};
 
   "tidal-vis" = callPackage
-    ({ mkDerivation, base, cairo, colour, tidal }:
+    ({ mkDerivation, async, base, cairo, colour, containers, gloss
+     , hashable, hosc, mtl, network, SDL, SDL-gfx, SDL-image, SDL-ttf
+     , tidal, time, unagi-chan
+     }:
      mkDerivation {
        pname = "tidal-vis";
-       version = "0.9.3";
-       sha256 = "1sj17czyzpfrq0a8kalr170dw1zcphix0dnhdf6ggryskb1wswdp";
-       libraryHaskellDepends = [ base cairo colour tidal ];
-       description = "Visual rendering for Tidal patterns";
+       version = "1.0.14";
+       sha256 = "1l924nqv8ljd9ljpy05r18j0rc5if3k5lvpifv2g8fn967gi0nfs";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async base cairo colour containers gloss hashable hosc mtl network
+         SDL SDL-gfx SDL-image SDL-ttf tidal time unagi-chan
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Visual rendering for Tidal patterns and osc messages";
        license = stdenv.lib.licenses.gpl3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "tls_1_5_0" = callPackage
+  "tls_1_5_1" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-types, async, base, bytestring
      , cereal, cryptonite, data-default-class, gauge, hourglass, memory
      , mtl, network, QuickCheck, tasty, tasty-quickcheck, transformers
···
      }:
      mkDerivation {
        pname = "tls";
-       version = "1.5.0";
-       sha256 = "04hdk8mdn8l928prj1h37xkn4ny44bnkrbbknxyqjba51y5y30bc";
+       version = "1.5.1";
+       sha256 = "1fs5q494ip8hi2jdp34wy93hmdd42lwkh1hi0jg3ngdnilpg33yi";
        libraryHaskellDepends = [
          asn1-encoding asn1-types async base bytestring cereal cryptonite
          data-default-class hourglass memory mtl network transformers x509
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "tls-debug_0_4_6" = callPackage
+  "tls-debug_0_4_7" = callPackage
     ({ mkDerivation, base, bytestring, cryptonite, data-default-class
      , network, pem, tls, tls-session-manager, x509, x509-store
      , x509-system, x509-validation
      }:
      mkDerivation {
        pname = "tls-debug";
-       version = "0.4.6";
-       sha256 = "0xfjwyiazjdyba6x9bps93ibah9p22ww24wlmr6iksfsdhs79l7n";
+       version = "0.4.7";
+       sha256 = "1p3ihky5vznjv66f1mbpj33ahkg8g0xgfknldzmgllwsmh533dji";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "In-memory TLS session manager";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "tls-session-manager_0_0_3" = callPackage
+    ({ mkDerivation, auto-update, base, basement, bytestring, clock
+     , memory, psqueues, tls
+     }:
+     mkDerivation {
+       pname = "tls-session-manager";
+       version = "0.0.3";
+       sha256 = "0k57flqp2b4bipafiyfipnqmdqv04ky39yr4s4s9sx577zz2j2yi";
+       libraryHaskellDepends = [
+         auto-update base basement bytestring clock memory psqueues tls
+       ];
+       description = "In-memory TLS session manager";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "tmapchan" = callPackage
···
        broken = true;
      }) {};
 
-  "tomland_1_1_0_0" = callPackage
+  "tomland_1_1_0_1" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, deepseq
-     , gauge, hashable, hedgehog, hspec-megaparsec, htoml
+     , directory, gauge, hashable, hedgehog, hspec-megaparsec, htoml
      , htoml-megaparsec, markdown-unlit, megaparsec, mtl, parsec
      , parser-combinators, tasty, tasty-discover, tasty-hedgehog
      , tasty-hspec, tasty-silver, text, time, toml-parser, transformers
···
      }:
      mkDerivation {
        pname = "tomland";
-       version = "1.1.0.0";
-       sha256 = "0ip3pp76jf6di18r10ksxw35a2594k7h1iygm0b4k77m4fx4bqzn";
+       version = "1.1.0.1";
+       sha256 = "0ihz8pvcnr33mydz4n7gsayikh50pn1bg3km2h3nlv054lff7kai";
+       revision = "1";
+       editedCabalFile = "16382q0q77bv9zlahmgbmc90hvl1b23g9fxk4dl2f1lhlfqjkxnw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        executableHaskellDepends = [ base text time unordered-containers ];
        executableToolDepends = [ markdown-unlit ];
        testHaskellDepends = [
-         base bytestring containers hashable hedgehog hspec-megaparsec
-         megaparsec tasty tasty-hedgehog tasty-hspec tasty-silver text time
-         unordered-containers
+         base bytestring containers directory hashable hedgehog
+         hspec-megaparsec megaparsec tasty tasty-hedgehog tasty-hspec
+         tasty-silver text time unordered-containers
        ];
        testToolDepends = [ tasty-discover ];
        benchmarkHaskellDepends = [
···
      , diversity, fgl, filepath, find-clumpiness, foldl, graphviz
      , hierarchical-clustering, hierarchical-spectral-clustering
      , hmatrix, inline-r, lens, managed, matrix-market-attoparsec
-     , mltool, modularity, mtl, optparse-generic, palette, parallel
-     , plots, safe, scientific, sparse-linear-algebra
-     , spectral-clustering, split, statistics, streaming
-     , streaming-bytestring, streaming-cassava, streaming-utils
-     , streaming-with, SVGFonts, temporary, terminal-progress-bar, text
-     , text-show, transformers, vector, vector-algorithms, zlib
+     , modularity, mtl, optparse-generic, palette, parallel, plots, safe
+     , scientific, sparse-linear-algebra, spectral-clustering, split
+     , statistics, streaming, streaming-bytestring, streaming-cassava
+     , streaming-utils, streaming-with, SVGFonts, temporary
+     , terminal-progress-bar, text, text-show, transformers, vector
+     , vector-algorithms, zlib
      }:
      mkDerivation {
        pname = "too-many-cells";
-       version = "0.1.8.0";
-       sha256 = "0xf9q5x4ch4v1yr41fs155rvymdhslphj6d4dsjhf12ahq8rs5rl";
+       version = "0.1.12.2";
+       sha256 = "01jbz5a51myy4293637c9v2ac87cp60l4rax2gkdiqw8vj8231j4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          diagrams diagrams-cairo diagrams-graphviz diagrams-lib differential
          directory diversity fgl filepath find-clumpiness foldl graphviz
          hierarchical-clustering hierarchical-spectral-clustering hmatrix
-         inline-r lens managed matrix-market-attoparsec mltool modularity
-         mtl palette parallel plots safe scientific sparse-linear-algebra
-         split statistics streaming streaming-bytestring streaming-cassava
+         inline-r lens managed matrix-market-attoparsec modularity mtl
+         palette parallel plots safe scientific sparse-linear-algebra split
+         statistics streaming streaming-bytestring streaming-cassava
          streaming-with SVGFonts temporary text text-show vector
          vector-algorithms zlib
        ];
···
          aeson base birch-beer bytestring cassava colour containers
          diagrams-cairo diagrams-lib directory fgl filepath find-clumpiness
          graphviz hierarchical-spectral-clustering inline-r lens
-         matrix-market-attoparsec mtl optparse-generic palette plots
-         spectral-clustering streaming streaming-bytestring streaming-utils
-         terminal-progress-bar text text-show transformers vector
+         matrix-market-attoparsec modularity mtl optparse-generic palette
+         plots spectral-clustering streaming streaming-bytestring
+         streaming-utils terminal-progress-bar text text-show transformers
+         vector
        ];
        description = "Cluster single cells and analyze cell clade relationships";
        license = stdenv.lib.licenses.gpl3;
···
 
   "toodles" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
-     , bytestring, cmdargs, directory, extra, hspec, hspec-expectations
-     , megaparsec, MissingH, process, regex-posix, RSA, servant
-     , servant-blaze, servant-server, strict, text, time, wai, warp
-     , yaml
+     , bytestring, cmdargs, directory, extra, filepath, hspec
+     , hspec-expectations, megaparsec, MissingH, process, regex-posix
+     , RSA, servant, servant-blaze, servant-server, strict, text, time
+     , wai, warp, yaml
      }:
      mkDerivation {
        pname = "toodles";
-       version = "1.2.1";
-       sha256 = "19z8xx8pw66m9q9xq0qldpzhmjwfsln4hn8smmz2pjk2x713883c";
+       version = "1.2.3";
+       sha256 = "0b6sznzkcjhs5fw920ivmvh6n6walamy16602bxid7sjrlgdjzcf";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        executableHaskellDepends = [
          aeson base base64-bytestring blaze-html bytestring cmdargs
-         directory extra megaparsec MissingH process regex-posix RSA servant
-         servant-blaze servant-server strict text time wai warp yaml
+         directory extra filepath megaparsec MissingH process regex-posix
+         RSA servant servant-blaze servant-server strict text time wai warp
+         yaml
        ];
        testHaskellDepends = [
          aeson base base64-bytestring blaze-html bytestring cmdargs
···
      }:
      mkDerivation {
        pname = "tpdb";
-       version = "2.1.1";
-       sha256 = "0hk592dki8hp15a84pnqnjdwql2zczfask71gxf833i0vrph38yb";
+       version = "2.2.0";
+       sha256 = "1hrnfvp49rny9rznnhlhvgw4ffmn9nbbdiknsbwxgjfh1ixir1vf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Distributed tracing";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "tracker" = callPackage
···
      }:
      mkDerivation {
        pname = "traction";
-       version = "0.1.0";
-       sha256 = "1vf6hrzxr28yp6rijdxcq83c60hzkyvjkc2caiifmfi5ay2hzlzq";
+       version = "0.2.0";
+       sha256 = "1rbbp2sw5i1x499bhi1d0f37m34rf6j9p2ndlqsijallmdiawcgq";
        libraryHaskellDepends = [
          base bytestring containers exceptions mmorph postgresql-simple
          resource-pool syb template-haskell text time transformers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "transformers-except" = callPackage
+    ({ mkDerivation, base, exceptions, text, transformers }:
+     mkDerivation {
+       pname = "transformers-except";
+       version = "0.1.1";
+       sha256 = "1i89k4bml223f7m3pin73vrz51xb2j7q7rr39x9v587hmm40mvkm";
+       libraryHaskellDepends = [ base exceptions text transformers ];
+       description = "An Except monad transformer with";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "transformers-fix" = callPackage
     ({ mkDerivation, base, transformers }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "trasa";
-       version = "0.4";
-       sha256 = "059zbm4bfzcv0qlvr55l49xs5izycb2hdjbyqvri5f3vrnwnic1q";
+       version = "0.4.1";
+       sha256 = "0nnr72h6ylx52ni6l7r0nnv02d540agzfhyjfjrxywbx7xz70q5c";
        libraryHaskellDepends = [
          base binary bytestring hashable http-media http-types
          quantification text unordered-containers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "trasa-extra" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, case-insensitive
+     , containers, cookie, http-types, mtl, path-pieces, quantification
+     , text, trasa, trasa-server
+     }:
+     mkDerivation {
+       pname = "trasa-extra";
+       version = "0.1.0.0";
+       sha256 = "0ka5w55zzx7cy17pwdwcjf20yl0lmpg6bqv874k0ia7hihl6sx6c";
+       libraryHaskellDepends = [
+         aeson base bytestring case-insensitive containers cookie http-types
+         mtl path-pieces quantification text trasa trasa-server
+       ];
+       description = "Extra functions for trasa";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "trasa-form" = callPackage
+    ({ mkDerivation, base, bytestring, cookie, ditto, ditto-lucid
+     , http-api-data, http-types, lucid, mtl, quantification, text
+     , trasa, trasa-server, unordered-containers
+     }:
+     mkDerivation {
+       pname = "trasa-form";
+       version = "0.3.2.0";
+       sha256 = "0q59wkg7k66iq8n6b73226z23sgy8pfvylac9qvlaiib6dllq1g8";
+       libraryHaskellDepends = [
+         base bytestring cookie ditto ditto-lucid http-api-data http-types
+         lucid mtl quantification text trasa trasa-server
+         unordered-containers
+       ];
+       description = "generate forms using lucid, ditto and trasa";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "trasa-reflex" = callPackage
     ({ mkDerivation, base, bytestring, containers, ghcjs-dom
      , http-media, http-types, jsaddle, reflex, reflex-dom, text, trasa
···
      }:
      mkDerivation {
        pname = "trasa-server";
-       version = "0.4";
-       sha256 = "1xh85kh9ilsq8zy19if4s93zmjqxbpgqpvhkh9jpk8klia7zc0pv";
+       version = "0.5.4";
+       sha256 = "1z3cq2zfygxf1v7ifga23mf7zn750925cvghmb3i54a9r0wafmb2";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers http-media http-types
          mtl text trasa wai
···
        testHaskellDepends = [ base trasa ];
        description = "Template Haskell to generate trasa routes";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "traverse-with-class" = callPackage
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "trivial-constraint";
-       version = "0.5.1.0";
-       sha256 = "0wk925w1qswr5ma6427p0p1gl96hr1pfdqkn08r3ccpbibz6q1sy";
+       version = "0.6.0.0";
+       sha256 = "0y0iyll7ml5qz271cqa0dc3w2j3w1d8jjaxwaf2flcidigws69z5";
        libraryHaskellDepends = [ base ];
        description = "Constraints that any type, resp. no type fulfills";
        license = stdenv.lib.licenses.gpl3;
···
        broken = true;
      }) {};
 
+  "type-errors-pretty" = callPackage
+    ({ mkDerivation, base, doctest, Glob }:
+     mkDerivation {
+       pname = "type-errors-pretty";
+       version = "0.0.0.0";
+       sha256 = "0yj8c91maanihyl9506ihpxv3zyfvprr359dvd2b9ym3py50kncs";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base doctest Glob ];
+       description = "Combinators for writing pretty type errors easily";
+       license = stdenv.lib.licenses.mpl20;
+     }) {};
+
   "type-fun" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "typesafe-precure";
-       version = "0.7.4.1";
-       sha256 = "1nm74fj819kws9rrksk80gyrl3m5dxsm17bm2a18mp8dca76iix2";
+       version = "0.7.5.1";
+       sha256 = "0n2cnd15gwixk17jqcz4hxishikscwbcn2gnrkcz3a295ng68ins";
        libraryHaskellDepends = [
          aeson aeson-pretty autoexporter base bytestring dlist
          monad-skeleton template-haskell text th-data-compat
···
        pname = "ucam-webauth";
        version = "0.1.0.0";
        sha256 = "14l989aasyqdw1x7aq9ikhcq9p3s1ax4qk53rd5s53wdgbc20n9k";
-       revision = "5";
-       editedCabalFile = "1hii6sjyc3dps800ffwkjq6fq82idlpkdv68k1y9ivv477plw24a";
+       revision = "6";
+       editedCabalFile = "1dammzdhin226byx8p287kdnn9pc7s49hfxcdmflly6hsy1psnvy";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers cryptonite errors
          http-api-data http-types microlens microlens-mtl mtl
···
      }) {};
 
   "unbeliever" = callPackage
-    ({ mkDerivation, aeson, async, base, bytestring, chronologique
-     , containers, deepseq, directory, exceptions, fingertree, gauge
-     , hashable, hourglass, hspec, mtl, prettyprinter
-     , prettyprinter-ansi-terminal, safe-exceptions, scientific, stm
-     , template-haskell, terminal-size, text, text-short, transformers
-     , unix, unordered-containers, vector
+    ({ mkDerivation, base, bytestring, core-data, core-program
+     , core-text, fingertree, gauge, hspec, safe-exceptions, text
+     , text-short
      }:
      mkDerivation {
        pname = "unbeliever";
-       version = "0.9.3.2";
-       sha256 = "1gsjmr9h7w08576smi978k5djhvjk4ry0ljgr6zxx7nj7cy1m84b";
-       revision = "1";
-       editedCabalFile = "0mlbjb79ylk2jb7mp6da1xfl2r28zfijwv5dd2l73l9mgi5h0s72";
-       libraryHaskellDepends = [
-         aeson async base bytestring chronologique containers deepseq
-         directory exceptions fingertree hashable hourglass mtl
-         prettyprinter prettyprinter-ansi-terminal safe-exceptions
-         scientific stm template-haskell terminal-size text text-short
-         transformers unix unordered-containers vector
-       ];
+       version = "0.10.0.1";
+       sha256 = "0fmv76xmi4ansrksa07vidqvxiqgdmvvampkqngi1ma7g3k2n29x";
+       libraryHaskellDepends = [ base core-data core-program core-text ];
        testHaskellDepends = [
-         aeson async base bytestring chronologique containers deepseq
-         directory exceptions fingertree hashable hourglass hspec mtl
-         prettyprinter prettyprinter-ansi-terminal safe-exceptions
-         scientific stm template-haskell terminal-size text text-short
-         transformers unix unordered-containers vector
+         base bytestring core-data core-program core-text fingertree hspec
+         safe-exceptions text text-short
        ];
        benchmarkHaskellDepends = [
-         aeson async base bytestring chronologique containers deepseq
-         directory exceptions fingertree gauge hashable hourglass mtl
-         prettyprinter prettyprinter-ansi-terminal safe-exceptions
-         scientific stm template-haskell terminal-size text text-short
-         transformers unix unordered-containers vector
+         base bytestring core-data core-program core-text gauge text
        ];
+       doHaddock = false;
        description = "Opinionated Haskell Interoperability";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        pname = "union";
        version = "0.1.2";
        sha256 = "1i4fvlwkw1wx64a6l8342aqfqsdq7fqa4p24g3i5gn5704lxrsb3";
-       revision = "2";
-       editedCabalFile = "170dhg4z4jzi50nh4xx75r9k8zz5br7j2iqjjw2r1dx29ajqbcw9";
+       revision = "3";
+       editedCabalFile = "160jc4ykqvkzw79sb9j95mw7hsnknpfhkbbd75xmkpx08vnv4d76";
        libraryHaskellDepends = [
          base deepseq hashable profunctors tagged vinyl
        ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "unliftio_0_2_12" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, deepseq
+     , directory, filepath, gauge, hspec, process, QuickCheck, stm, time
+     , transformers, unix, unliftio-core
+     }:
+     mkDerivation {
+       pname = "unliftio";
+       version = "0.2.12";
+       sha256 = "02gy1zrxgzg4xmzm8lafsf1nyr3as1q20r8ld73xg3q7rkag9acg";
+       libraryHaskellDepends = [
+         async base bytestring deepseq directory filepath process stm time
+         transformers unix unliftio-core
+       ];
+       testHaskellDepends = [
+         async base bytestring containers deepseq directory filepath hspec
+         process QuickCheck stm time transformers unix unliftio-core
+       ];
+       benchmarkHaskellDepends = [
+         async base bytestring deepseq directory filepath gauge process stm
+         time transformers unix unliftio-core
+       ];
+       description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "unliftio-core" = callPackage
     ({ mkDerivation, base, transformers }:
      mkDerivation {
···
        ];
        description = "Command-line tool to generate paths for moving upward in a file system";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "up-grade" = callPackage
···
        ];
        description = "Painfully simple URL deployment";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "urn" = callPackage
···
        license = stdenv.lib.licenses.publicDomain;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
+     }) {};
+
+  "usa-holidays" = callPackage
+    ({ mkDerivation, base, doctest, doctest-discover, hspec, time }:
+     mkDerivation {
+       pname = "usa-holidays";
+       version = "0.1.0.1";
+       sha256 = "04biw4l5rpfcflrmcn45hlirq26bpzs27745jhyr32gl6mpnqb12";
+       libraryHaskellDepends = [ base time ];
+       testHaskellDepends = [ base doctest doctest-discover hspec time ];
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "usb" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "vault_0_3_1_3" = callPackage
+    ({ mkDerivation, base, containers, hashable, semigroups
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "vault";
+       version = "0.3.1.3";
+       sha256 = "0vdm472vn734xa27jjm2mjacl37mxiqaaahvm4hzqjgyh4cqq377";
+       libraryHaskellDepends = [
+         base containers hashable semigroups unordered-containers
+       ];
+       description = "a persistent store for values of arbitrary types";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "vault-tool" = callPackage
     ({ mkDerivation, aeson, base, bytestring, http-client
      , http-client-tls, http-types, text, unordered-containers
···
        ];
        description = "types for ingesting vflow data with aeson";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "vfr-waypoints" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "wai-extra_3_0_27" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, base64-bytestring
+     , bytestring, case-insensitive, containers, cookie
+     , data-default-class, deepseq, directory, fast-logger, hspec
+     , http-types, http2, HUnit, iproute, network, old-locale, resourcet
+     , streaming-commons, text, time, transformers, unix, unix-compat
+     , vault, void, wai, wai-logger, word8, zlib
+     }:
+     mkDerivation {
+       pname = "wai-extra";
+       version = "3.0.27";
+       sha256 = "1p8x61xjbwjif10iibc3b2gxh3dd3rymrfvinrdn0h9wn7qsyh2x";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson ansi-terminal base base64-bytestring bytestring
+         case-insensitive containers cookie data-default-class deepseq
+         directory fast-logger http-types http2 iproute network old-locale
+         resourcet streaming-commons text time transformers unix unix-compat
+         vault void wai wai-logger word8 zlib
+       ];
+       testHaskellDepends = [
+         base bytestring case-insensitive cookie fast-logger hspec
+         http-types http2 HUnit resourcet text time transformers wai zlib
+       ];
+       description = "Provides some basic WAI handlers and middleware";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "wai-frontend-monadcgi" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, cgi
      , containers, http-types, transformers, wai
···
      }:
      mkDerivation {
        pname = "wai-http2-extra";
-       version = "0.1.1";
-       sha256 = "00fr1rg92vfkn6cb7cgdwmj7lavmyj8m9y0xxj05ws4b93r5f2z5";
+       version = "0.1.2";
+       sha256 = "1f4ddgrprdnbpdbb6jj8n2ib206dlj5mgf8ar6r1ls2p90vpn6yr";
        libraryHaskellDepends = [
          auto-update base bytestring containers http-types wai warp word8
        ];
···
        pname = "warc";
        version = "1.0.4";
        sha256 = "1mxfm8kdvm0l1lnzma4n9mriz94ypckxqcz1f34fa3n1j3ckc45b";
-       revision = "1";
-       editedCabalFile = "1mdd3r1lg92rchy1zv4jwvrsn6x3wnplhbnwavpx0nivf3xp7m8q";
+       revision = "2";
+       editedCabalFile = "0vlh1wivzs2ikmp3jbx4m0zxyvkjy1rn6xhbgaz1n5vi37hid74n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          base boomerang mtl parsec text web-routes
        ];
        description = "Use boomerang for type-safe URL parsers/printers";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "web-routes-generics" = callPackage
+    ({ mkDerivation, base, parsec, text, web-routes }:
+     mkDerivation {
+       pname = "web-routes-generics";
+       version = "0.1.0.1";
+       sha256 = "16nykkzjznl9zq2qgn87lpqxkz8yx83s7949lv4vzapp4hjv04yy";
+       libraryHaskellDepends = [ base parsec text web-routes ];
+       description = "portable, type-safe URL routing";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "winery_1_1_1" = callPackage
+  "winery_1_1_2" = callPackage
     ({ mkDerivation, aeson, base, binary, bytestring, cereal
      , containers, cpu, deepseq, directory, fast-builder, gauge
      , hashable, HUnit, megaparsec, mtl, prettyprinter
      , prettyprinter-ansi-terminal, QuickCheck, quickcheck-instances
-     , scientific, semigroups, serialise, text, time, transformers
-     , unordered-containers, vector
+     , scientific, semigroups, serialise, store, text, time
+     , transformers, unordered-containers, vector
      }:
      mkDerivation {
        pname = "winery";
-       version = "1.1.1";
-       sha256 = "0jyr5vwz55rjwqvvh2ys3aq426i6jhfrykz0mx4kidr9l9yd0yls";
+       version = "1.1.2";
+       sha256 = "1hxs3pyv0icqmnmnjadr86d55jdi689hgcjgx3lq7skxs3hp0qf1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        benchmarkHaskellDepends = [
          aeson base binary bytestring cereal deepseq directory gauge
-         serialise text
+         serialise store text
        ];
        description = "A compact, well-typed seralisation format for Haskell values";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.isc;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) wlc;};
+     }) {wlc = null;};
 
   "wobsurv" = callPackage
     ({ mkDerivation, aeson, attoparsec, base-prelude, bytestring
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "world-peace_1_0_0_0" = callPackage
+  "world-peace_1_0_1_0" = callPackage
     ({ mkDerivation, aeson, base, deepseq, doctest, Glob, profunctors
      , should-not-typecheck, tagged, tasty, tasty-hunit, text
      }:
      mkDerivation {
        pname = "world-peace";
-       version = "1.0.0.0";
-       sha256 = "1fx8f7dfrslqwmkbcyff5q7iafa5znc73f77il7y87hz23q9yzmx";
+       version = "1.0.1.0";
+       sha256 = "1fx7y9h1yyjc5xn1mpbkwas6p6h06rivzndb545z1qnnp583vzwp";
        libraryHaskellDepends = [ aeson base deepseq profunctors tagged ];
        testHaskellDepends = [
          base doctest Glob should-not-typecheck tasty tasty-hunit text
···
        ];
        description = "A simple CLI utility for interacting with a websocket";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "ws-chans" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "yam_0_6_3" = callPackage
+  "yam_0_7" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, binary, bytestring
      , data-default, exceptions, fast-logger, hspec, http-client
      , http-types, lens, menshen, monad-logger, mtl, mwc-random
···
      }:
      mkDerivation {
        pname = "yam";
-       version = "0.6.3";
-       sha256 = "1mw4yylh8cmrm22cqpdkd64idklkwig8c4rbvrmpw5j5s0hdmdly";
+       version = "0.7";
+       sha256 = "1b1igh82zhdbql4kfjxxh1rg1776x2yv2755hnvps5p06c2wap7z";
        libraryHaskellDepends = [
          aeson base base16-bytestring binary bytestring data-default
          exceptions fast-logger http-client http-types lens menshen
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "yam-datasource_0_6_3" = callPackage
+  "yam-datasource_0_7" = callPackage
     ({ mkDerivation, base, conduit, data-default, monad-logger
      , persistent, resource-pool, resourcet, salak, servant-server, text
      , unliftio-core, yam
      }:
      mkDerivation {
        pname = "yam-datasource";
-       version = "0.6.3";
-       sha256 = "0zcwd32iz01b3m3xg1n3axvrljbkcld196pblc7cn0kb2n0w6ilp";
+       version = "0.7";
+       sha256 = "0dkricvyypyggbmqp3mqryz7sw1z1z92ixnvz48lc8xqahvj0fsv";
        libraryHaskellDepends = [
          base conduit data-default monad-logger persistent resource-pool
          resourcet salak servant-server text unliftio-core yam
···
      }:
      mkDerivation {
        pname = "yam-redis";
-       version = "0.6.3";
-       sha256 = "0xvv9azq8ihyxgz11089xkvxmisp6ajggldayj8bdg045m74lv9r";
+       version = "0.7";
+       sha256 = "0cw4prkmi2csmi1kw3k0lvvzhnl71f4fplsv3f2jxgcgviim89pw";
        libraryHaskellDepends = [
          base bytestring data-default hedis menshen monad-logger mtl salak
          servant-server text yam
···
        libraryHaskellDepends = [ base deriving-compat hedgehog yaya ];
        description = "Hedgehog testing support for the Yaya recursion scheme library";
        license = stdenv.lib.licenses.agpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "yaya-unsafe" = callPackage
···
        testHaskellDepends = [ base hspec text time ];
        description = "Form handling support for Yesod Web Framework";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "yesod-form_1_6_6" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
+     , blaze-markup, byteable, bytestring, containers, data-default
+     , email-validate, hspec, network-uri, persistent, resourcet
+     , semigroups, shakespeare, text, time, transformers, wai
+     , xss-sanitize, yesod-core, yesod-persistent
+     }:
+     mkDerivation {
+       pname = "yesod-form";
+       version = "1.6.6";
+       sha256 = "16m7m7yixsnka926znjy0xn0kp30mbvjq2f46rh987kdr28dks9p";
+       libraryHaskellDepends = [
+         aeson attoparsec base blaze-builder blaze-html blaze-markup
+         byteable bytestring containers data-default email-validate
+         network-uri persistent resourcet semigroups shakespeare text time
+         transformers wai xss-sanitize yesod-core yesod-persistent
+       ];
+       testHaskellDepends = [ base hspec text time ];
+       description = "Form handling support for Yesod Web Framework";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yesod-form-bootstrap4" = callPackage