Merge pull request #114517 from NixOS/haskell-updates

Update Haskell package set to Stackage Nightly 2021-02-25 (plus other fixes)

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

···
   # Due to tests restricting base in 0.8.0.0 release
   http-media = doJailbreak super.http-media;
 
-  # Use an already merged upstream patch fixing the build with primitive >= 0.7.2
-  # The version bounds were correctly specified before, so we need to jailbreak as well
-  streamly = appendPatch (doJailbreak super.streamly) (pkgs.fetchpatch {
-    url = "https://github.com/composewell/streamly/commit/2c88cb631fdcb5c0d3a8bc936e1e63835800be9b.patch";
-    sha256 = "0g2m0y46zr3xs9fswkm4h9adhsg6gzl5zwgidshsjh3k3rq4h7b1";
-  });
-
   # https://github.com/ekmett/half/issues/35
   half = if pkgs.stdenv.isAarch64
     then dontCheck super.half

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

···
   vector = dontCheck super.vector;
 
   mmorph = super.mmorph_1_1_3;
+
+  # https://github.com/haskellari/time-compat/issues/23
+  time-compat = dontCheck super.time-compat;
+
 }

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

···
     url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/alex-3.2.5.patch";
     sha256 = "0q8x49k3jjwyspcmidwr6b84s4y43jbf4wqfxfm6wz8x2dxx6nwh";
   });
-  doctest = appendPatch (dontCheck (doJailbreak super.doctest_0_18)) (pkgs.fetchpatch {
-    url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/doctest-0.17.patch";
-    sha256 = "16s2jcbk9hsww38i2wzxghbf0zpp5dc35hp6rd2n7d4z5xfavp62";
-  });
+  doctest = dontCheck (doJailbreak super.doctest_0_18_1);
   generic-deriving = appendPatch (doJailbreak super.generic-deriving) (pkgs.fetchpatch {
     url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/generic-deriving-1.13.1.patch";
     sha256 = "0z85kiwhi5p2wiqwyym0y8q8qrcifp125x5vm0n4482lz41kmqds";

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

···
   # gi-gdkx11-4.x requires gtk-4.x, which is still under development and
   # not yet available in Nixpkgs
   - gi-gdkx11 < 4
-  - ghcide < 0.7.4 # for hls 0.9.0
-  - hls-explicit-imports-plugin < 0.1.0.1 # for hls 0.9.0
-  - hls-plugin-api < 0.7.1.0 # for hls 0.9.0
-  - hls-retrie-plugin < 0.1.1.1 # for hls 0.9.0
-
-  # Stackage Nightly 2021-02-25
+  # Don't update yet to remain compatible with haskell-language-server-0.9.0.
+  - ghcide < 0.7.4
+  - hls-class-plugin < 1
+  - hls-explicit-imports-plugin < 0.1.0.1
+  - hls-haddock-comments-plugin < 1
+  - hls-plugin-api < 0.7.1.0
+  - hls-retrie-plugin < 0.1.1.1
+  - hls-tactics-plugin < 1
+  # Stackage Nightly 2021-03-01
   - abstract-deque ==0.3
   - abstract-par ==0.3.3
   - AC-Angle ==1.0
···
   - attoparsec-iso8601 ==1.0.2.0
   - attoparsec-path ==0.0.0.1
   - audacity ==0.0.2
-  - aur ==7.0.5
-  - aura ==3.2.2
+  - aur ==7.0.6
+  - aura ==3.2.3
   - authenticate ==1.3.5
   - authenticate-oauth ==1.6.0.1
   - auto ==0.4.3.1
···
   - bimap ==0.4.0
   - bimaps ==0.1.0.2
   - bimap-server ==0.1.0.1
-  - bin ==0.1
+  - bin ==0.1.1
   - binary-conduit ==1.3.1
   - binary-ext ==2.0.4
   - binary-ieee754 ==0.1.0.0
···
   - bitset-word8 ==0.1.1.2
   - bits-extra ==0.0.2.0
   - bitvec ==1.1.1.0
-  - bitwise-enum ==1.0.0.3
+  - bitwise-enum ==1.0.1.0
   - blake2 ==0.3.0
   - blanks ==0.5.0
   - blas-carray ==0.1.0.1
···
   - fast-logger ==3.0.3
   - fast-math ==1.0.2
   - fb ==2.1.1
+  - fclabels ==2.0.5
   - feature-flags ==0.1.0.1
   - fedora-dists ==1.1.2
   - fedora-haskell-tools ==0.9
···
   - filepattern ==0.1.2
   - fileplow ==0.1.0.0
   - filtrable ==0.1.4.0
-  - fin ==0.1.1
+  - fin ==0.2
   - FindBin ==0.0.5
   - fingertree ==0.1.4.2
   - finite-typelits ==0.1.4.2
···
   - focuslist ==0.1.0.2
   - foldable1 ==0.1.0.0
   - fold-debounce ==0.2.0.9
-  - fold-debounce-conduit ==0.2.0.5
-  - foldl ==1.4.10
+  - fold-debounce-conduit ==0.2.0.6
+  - foldl ==1.4.11
   - folds ==0.7.6
   - follow-file ==0.0.3
   - FontyFruity ==0.5.3.5
···
   - ghc-source-gen ==0.4.0.0
   - ghc-syntax-highlighter ==0.0.6.0
   - ghc-tcplugins-extra ==0.4.1
-  - ghc-trace-events ==0.1.2.1
+  - ghc-trace-events ==0.1.2.2
   - ghc-typelits-extra ==0.4.2
   - ghc-typelits-knownnat ==0.7.5
   - ghc-typelits-natnormalise ==0.7.4
···
   - haskell-src ==1.0.3.1
   - haskell-src-exts ==1.23.1
   - haskell-src-exts-util ==0.2.5
-  - haskell-src-meta ==0.8.5
+  - haskell-src-meta ==0.8.7
   - haskey-btree ==0.3.0.1
   - hasql ==1.4.4.2
   - hasql-notifications ==0.1.0.0
···
   - hexstring ==0.11.1
   - hformat ==0.3.3.1
   - hfsevents ==0.1.6
-  - hgeometry ==0.11.0.0
-  - hgeometry-combinatorial ==0.11.0.0
   - hgrev ==0.2.6
   - hidapi ==0.1.5
   - hie-bios ==0.7.4
···
   - hint ==0.9.0.3
   - hjsmin ==0.2.0.4
   - hkd-default ==1.1.0.0
-  - hkgr ==0.2.6.1
+  - hkgr ==0.2.7
   - hlibcpuid ==0.2.0
   - hlibgit2 ==0.18.0.16
   - hlibsass ==0.1.10.1
···
   - httpd-shed ==0.4.1.1
   - http-link-header ==1.0.3.1
   - http-media ==0.8.0.0
-  - http-query ==0.1.0
+  - http-query ==0.1.0.1
   - http-reverse-proxy ==0.6.0
   - http-streams ==0.8.7.2
   - http-types ==0.12.3
···
   - lens-datetime ==0.3
   - lens-family ==2.0.0
   - lens-family-core ==2.0.0
-  - lens-family-th ==0.5.1.0
+  - lens-family-th ==0.5.2.0
   - lens-misc ==0.0.2.0
   - lens-process ==0.4.0.0
   - lens-properties ==4.11.1
···
   - libyaml ==0.1.2
   - LibZip ==1.0.1
   - life-sync ==1.1.1.0
-  - lifted-async ==0.10.1.2
+  - lifted-async ==0.10.1.3
   - lifted-base ==0.2.3.12
   - lift-generics ==0.2
   - line ==4.0.1
···
   - lrucache ==1.2.0.1
   - lrucaching ==0.3.3
   - lsp-test ==0.11.0.5
-  - lucid ==2.9.12
+  - lucid ==2.9.12.1
   - lucid-cdn ==0.2.2.0
   - lucid-extras ==0.2.2
   - lukko ==0.1.1.3
···
   - monad-chronicle ==1.0.0.1
   - monad-control ==1.0.2.3
   - monad-control-aligned ==0.0.1.1
-  - monad-coroutine ==0.9.0.4
+  - monad-coroutine ==0.9.1
   - monad-extras ==0.6.0
   - monadic-arrays ==0.2.2
   - monad-journal ==0.8.1
···
   - monad-memo ==0.5.3
   - monad-metrics ==0.2.2.0
   - monad-par ==0.3.5
-  - monad-parallel ==0.7.2.3
+  - monad-parallel ==0.7.2.4
   - monad-par-extras ==0.3.3
   - monad-peel ==0.2.1.2
   - monad-primitive ==0.1
···
   - netlib-carray ==0.1
   - netlib-comfort-array ==0.0.0.1
   - netlib-ffi ==0.1.1
-  - netpbm ==1.0.3
+  - netpbm ==1.0.4
   - nettle ==0.3.0
   - netwire ==5.0.3
   - netwire-input ==0.0.7
···
   - pipes-http ==1.0.6
   - pipes-network ==0.6.5
   - pipes-network-tls ==0.4
-  - pipes-ordered-zip ==1.1.0
+  - pipes-ordered-zip ==1.2.1
   - pipes-parse ==3.0.9
   - pipes-random ==1.0.0.5
   - pipes-safe ==2.3.3
···
   - prelude-safeenum ==0.1.1.2
   - prettyclass ==1.0.0.0
   - pretty-class ==1.0.1.1
-  - pretty-diff ==0.4.0.2
+  - pretty-diff ==0.4.0.3
   - pretty-hex ==1.1
   - prettyprinter ==1.7.0
   - prettyprinter-ansi-terminal ==1.1.2
···
   - radius ==0.7.1.0
   - rainbow ==0.34.2.2
   - rainbox ==0.26.0.0
-  - ral ==0.1
+  - ral ==0.2
   - rampart ==1.1.0.2
   - ramus ==0.1.2
   - rando ==0.0.0.4
···
   - readable ==0.3.1
   - read-editor ==0.1.0.2
   - read-env-var ==1.0.0.0
-  - reanimate ==1.1.3.3
-  - reanimate-svg ==0.13.0.1
   - rebase ==1.6.1
-  - record-dot-preprocessor ==0.2.8
+  - record-dot-preprocessor ==0.2.9
   - record-hasfield ==1.0
   - records-sop ==0.1.0.3
   - record-wrangler ==0.1.1.0
···
   - safe-json ==1.1.1.1
   - safe-money ==0.9
   - SafeSemaphore ==0.10.1
-  - safe-tensor ==0.2.1.0
+  - safe-tensor ==0.2.1.1
   - salak ==0.3.6
   - salak-yaml ==0.3.5.3
   - saltine ==0.1.1.1
···
   - seqalign ==0.2.0.4
   - seqid ==0.6.2
   - seqid-streams ==0.7.2
-  - sequence-formats ==1.5.2
+  - sequence-formats ==1.6.0
   - sequenceTools ==1.4.0.5
   - serf ==0.1.1.0
   - serialise ==0.2.3.0
···
   - setlocale ==1.0.0.9
   - sexp-grammar ==2.3.0
   - SHA ==1.6.4.4
+  - shake-language-c ==0.12.0
   - shake-plus ==0.3.3.1
   - shake-plus-extended ==0.4.1.0
   - shakespeare ==2.0.25
···
   - skein ==1.0.9.4
   - skews ==0.1.0.3
   - skip-var ==0.1.1.0
-  - skylighting ==0.10.3
-  - skylighting-core ==0.10.3
+  - skylighting ==0.10.4
+  - skylighting-core ==0.10.4
   - slack-api ==0.12
   - slack-progressbar ==0.1.0.1
   - slist ==0.1.1.0
···
   - sox ==0.2.3.1
   - soxlib ==0.0.3.1
   - sparse-linear-algebra ==0.3.1
-  - sparse-tensor ==0.2.1.4
+  - sparse-tensor ==0.2.1.5
   - spatial-math ==0.5.0.1
   - special-values ==0.1.0.0
   - speculate ==0.4.2
···
   - tardis ==0.4.3.0
   - tasty ==1.2.3
   - tasty-ant-xml ==1.1.7
-  - tasty-bench ==0.2.1
+  - tasty-bench ==0.2.2
   - tasty-dejafu ==2.0.0.7
   - tasty-discover ==4.2.2
   - tasty-expected-failure ==0.12.3
···
   - th-desugar ==1.11
   - th-env ==0.1.0.2
   - these ==1.1.1.1
-  - these-lens ==1.0.1.1
-  - these-optics ==1.0.1.1
+  - these-lens ==1.0.1.2
+  - these-optics ==1.0.1.2
   - these-skinny ==0.7.4
   - th-expand-syns ==0.4.6.0
   - th-extras ==0.0.0.4
···
   - th-test-utils ==1.1.0
   - th-utilities ==0.2.4.1
   - thyme ==0.3.5.5
-  - tidal ==1.7.1
+  - tidal ==1.7.2
   - tile ==0.3.0.0
   - time-compat ==1.9.5
   - timeit ==2.0
···
   - validity-vector ==0.2.0.3
   - valor ==0.1.0.0
   - vault ==0.3.1.5
-  - vec ==0.3
+  - vec ==0.4
   - vector ==0.12.2.0
   - vector-algorithms ==0.8.0.4
   - vector-binary-instances ==0.2.5.1
···
   - xdg-desktop-entry ==0.1.1.1
   - xdg-userdirs ==0.1.0.2
   - xeno ==0.4.2
-  - xlsx ==0.8.2
+  - xlsx ==0.8.3
   - xlsx-tabular ==0.2.2.1
   - xml ==1.3.14
   - xml-basic ==0.1.3.1
-  - xml-conduit ==1.9.0.0
+  - xml-conduit ==1.9.1.0
   - xml-conduit-writer ==0.1.1.2
   - xmlgen ==0.6.2.2
   - xml-hamlet ==0.5.0.1
···
   - yesod-form ==1.6.7
   - yesod-gitrev ==0.2.1
   - yesod-newsfeed ==1.7.0.0
-  - yesod-page-cursor ==2.0.0.3
+  - yesod-page-cursor ==2.0.0.4
   - yesod-paginator ==1.1.1.0
   - yesod-persistent ==1.6.0.5
   - yesod-sitemap ==1.6.0
···
   - zip-archive ==0.4.1
   - zipper-extra ==0.1.3.2
   - zippers ==0.3.1
-  - zip-stream ==0.2.0.1
+  - zip-stream ==0.2.1.0
   - zlib ==0.6.2.3
   - zlib-bindings ==0.1.1.5
   - zlib-lens ==0.1.2.1
···
   - aeson-applicative
   - aeson-decode
   - aeson-diff-generic
+  - aeson-extra
   - aeson-filthy
   - aeson-flowtyped
   - aeson-injector
···
   - alga
   - algebra-checkers
   - algebra-dag
+  - algebra-driven-design
   - algebra-sql
   - algebraic
   - algebraic-prelude
···
   - arbor-monad-metric
   - arbor-monad-metric-datadog
   - arch-hs
+  - arch-web
   - archive-libarchive
   - archiver
   - archlinux
···
   - aws-lambda
   - aws-lambda-haskell-runtime-wai
   - aws-lambda-runtime
+  - aws-larpi
   - aws-mfa-credentials
   - aws-performance-tests
   - aws-route53
···
   - binary-indexed-tree
   - binary-protocol
   - binary-protocol-zmq
-  - binary-search
   - binary-streams
   - binary-tagged
   - binary-typed
···
   - crf-chain2-generic
   - crf-chain2-tiers
   - critbit
+  - criterion-cmp
   - criterion-compare
   - criterion-plus
   - criterion-to-html
···
   - denominate
   - dense
   - dense-int-set
+  - dep-t
+  - dep-t-advice
   - dependent-hashmap
   - dependent-monoidal-map
   - dependent-state
···
   - dhall-fly
   - dhall-nix
   - dhall-nixpkgs
+  - dhall-recursive-adt
   - dhall-text
   - dhall-to-cabal
   - dhcp-lease-parser
···
   - docker-build-cacher
   - dockercook
   - docopt
+  - docrecords
   - DocTest
   - doctest-discover-configurator
   - doctest-driver-gen
···
   - ethereum-merkle-patricia-db
   - euphoria
   - eurofxref
+  - evdev
+  - evdev-streamly
   - eve-cli
   - event
   - event-driven
···
   - execs
   - executor
   - exference
+  - exh
   - exherbo-cabal
   - exif
   - exigo-schema
···
   - ftp-conduit
   - ftphs
   - FTPLine
+  - ftree
   - ftshell
   - full-sessions
   - fullstop
···
   - functional-arrow
   - functor
   - functor-combinators
+  - functor-combo
   - functor-friends
   - functor-infix
   - functor-products
···
   - fused-effects-squeal
   - fused-effects-th
   - fusion
+  - futhark
   - futun
   - future
   - fuzzy-time-gen
···
   - gelatin-gl
   - gelatin-sdl2
   - gelatin-shaders
+  - gemini-textboard
   - gemstone
   - gen-imports
   - gen-passwd
···
   - generic-church
   - generic-enum
   - generic-enumeration
+  - generic-labels
   - generic-lens-labels
   - generic-lucid-scaffold
   - generic-maybe
···
   - gross
   - GroteTrap
   - groundhog-converters
+  - group-theory
   - group-with
   - grouped-list
   - groups-generic
···
   - haskell-lsp-client
   - haskell-ml
   - haskell-mpfr
+  - haskell-mpi
   - haskell-neo4j-client
   - haskell-openflow
   - haskell-overridez
···
   - heckle
   - hedgehog-checkers
   - hedgehog-checkers-lens
+  - hedgehog-classes
   - hedgehog-fakedata
   - hedgehog-gen-json
   - hedgehog-generic
···
   - hGelf
   - hgen
   - hgeometric
+  - hgeometry
+  - hgeometry-combinatorial
   - hgeometry-ipe
   - hgeometry-svg
   - hgeos
···
   - hyperloglogplus
   - hyperpublic
   - hypher
+  - hzk
   - hzulip
   - i18n
   - I1M
···
   - introduction
   - introduction-test
   - intset
+  - invert
   - invertible-hlist
   - invertible-syntax
   - io-capture
···
   - json-incremental-decoder
   - json-litobj
   - json-pointer-hasql
+  - json-pointy
   - json-python
   - json-rpc-client
   - json-schema
   - json-sop
   - json-syntax
+  - json-to-haskell
   - json-togo
   - json-tokens
   - json-tools
···
   - koellner-phonetic
   - kontra-config
   - korfu
+  - kparams
   - kqueue
   - kraken
   - krank
···
   - lens-filesystem
   - lens-labels
   - lens-prelude
+  - lens-process
   - lens-simple
   - lens-text-encoding
   - lens-th-rewrite
···
   - line-bot-sdk
   - line-drawing
   - linear-algebra-cblas
+  - linear-base
   - linear-circuit
   - linear-code
   - linear-maps
···
   - linx-gateway
   - lio-eci11
   - lio-simple
+  - lion
   - lipsum-gen
   - liquid
   - liquid-base
···
   - LRU
   - ls-usb
   - lscabal
+  - lsfrom
   - LslPlus
   - lsystem
   - lti13
···
   - Michelangelo
   - miconix-test
   - micro-recursion-schemes
+  - microbase
   - microformats2-parser
   - microformats2-types
   - microgroove
···
   - ml-w
   - mlist
   - mm2
+  - mmark
+  - mmark-cli
+  - mmark-ext
   - mmsyn7h
   - mmtf
   - mmtl
···
   - morfeusz
   - morley
   - morloc
+  - morpheus-graphql-app
   - morpheus-graphql-cli
   - morphisms-functors
   - morphisms-functors-inventory
···
   - musicbrainz-email
   - musicScroll
   - musicxml
+  - musicxml2
   - mustache-haskell
   - mutable-iter
   - MutationOrder
···
   - phoityne
   - phone-numbers
   - phone-push
+  - phonetic-languages-examples
+  - phonetic-languages-properties
+  - phonetic-languages-simplified-lists-examples
+  - phonetic-languages-simplified-properties-lists
+  - phonetic-languages-simplified-properties-lists-double
   - phooey
   - photoname
   - phraskell
···
   - piet
   - pig
   - pinboard
-  - pinboard-notes-backup
   - pinch
   - pinch-gen
   - pinchot
···
   - pit
   - pitchtrack
   - pivotal-tracker
+  - pixel-printer
   - pixelated-avatar-generator
   - pkcs10
   - pkcs7
···
   - pure-zlib
   - purescheme-wai-routing-core
   - purescript
+  - purescript-ast
+  - purescript-cst
   - purescript-iso
   - purescript-tsd-gen
   - push-notifications
···
   - quickpull
   - quickset
   - Quickson
+  - quickspec
   - quicktest
   - quickwebapp
   - quipper
···
   - record-syntax
   - records
   - records-th
+  - recursion-schemes
+  - recursion-schemes-ext
   - recursors
   - red-black-record
   - reddit
···
   - regex-tdfa-pipes
   - regex-tdfa-quasiquoter
   - regex-tdfa-rc
+  - regex-tdfa-text
   - regex-tdfa-unittest
   - regex-tdfa-utf8
   - regex-tre
···
   - req-url-extra
   - reqcatcher
   - request-monad
+  - rere
   - rescue
   - reserve
   - reservoir
···
   - rfc-redis
   - rfc-servant
   - rg
+  - rhbzquery
   - rhythm-game-tutorial
   - rib
   - ribbit
···
   - riff
   - ring-buffer
   - ring-buffers
+  - rio-process-pool
   - riot
   - risc-v
   - risc386
···
   - roc-cluster-demo
   - rock
   - rocksdb-haskell
+  - rocksdb-haskell-jprupp
   - rocksdb-query
   - roku-api
   - rollbar
···
   - servant-server-namedargs
   - servant-smsc-ru
   - servant-snap
+  - servant-static-th
   - servant-streaming
   - servant-streaming-client
   - servant-streaming-docs
···
   - setoid
   - setters
   - sexp
+  - sexp-grammar
   - sexpr-parser
   - sext
   - SFML
···
   - shake-cabal-build
   - shake-dhall
   - shake-extras
+  - shake-futhark
   - shake-minify
   - shake-pack
   - shake-path
···
   - slot-lambda
   - sloth
   - slug
+  - slugify
   - slynx
   - small-bytearray-builder
   - smallarray
···
   - socketed
   - socketio
   - sockets
+  - sockets-and-pipes
   - socketson
   - sodium
   - soegtk
···
   - stackage-types
   - stackage-upload
   - stackage2nix
+  - stackcollapse-ghc
+  - staged-gg
   - standalone-derive-topdown
   - standalone-haddock
   - starling
···
   - streaming-utils
   - streaming-with
   - streamly-archive
+  - streamly-fsnotify
   - streamly-lmdb
   - streamproc
   - strelka
···
   - tasty-fail-fast
   - tasty-groundhog-converters
   - tasty-hedgehog-coverage
+  - tasty-html
   - tasty-integrate
   - tasty-jenkins-xml
   - tasty-laws
···
   - termination-combinators
   - termplot
   - terntup
+  - terraform-http-backend-pass
   - terrahs
   - tersmu
   - tesla
···
   - texrunner
   - text-all
   - text-and-plots
+  - text-ascii
   - text-containers
   - text-format-heavy
   - text-generic-pretty
···
   - type-structure
   - type-sub-th
   - type-tree
+  - type-unary
   - typeable-th
   - TypeClass
   - typed-encoding
···
   - uniprot-kb
   - uniqueid
   - uniquely-represented-sets
+  - uniqueness-periods-vector-examples
+  - uniqueness-periods-vector-properties
   - units-attoparsec
   - unittyped
   - unitym-yesod
···
   - unix-fcntl
   - unix-handle
   - unix-process-conduit
+  - unix-recursive
   - unix-simple
   - unlifted-list
+  - unliftio-messagebox
   - unliftio-streams
   - unm-hip
   - unordered-containers-rematch
···
   - vect-floating-accelerate
   - vect-opengl
   - vector-bytestring
+  - vector-circular
   - vector-clock
   - vector-conduit
   - vector-endian
···
   - vitrea
   - vk-aws-route53
   - VKHS
+  - vocoder
+  - vocoder-audio
+  - vocoder-conduit
+  - vocoder-dunai
   - voicebase
   - vowpal-utils
   - voyeur
···
   - xleb
   - xls
   - xlsior
-  - xlsx
   - xlsx-tabular
   - xlsx-templater
   - xml-catalog
   - xml-conduit-decode
+  - xml-conduit-selectors
   - xml-conduit-stylist
   - xml-enumerator
   - xml-enumerator-combinators
···
   - YACPong
   - yahoo-finance-api
   - yahoo-finance-conduit
+  - yahoo-prices
   - yahoo-web-search
   - yajl
   - yajl-enumerator
···
   - yap
   - yarr
   - yarr-image-io
+  - yasi
   - yavie
   - yaya-test
   - yaya-unsafe-test

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

···
        license = lib.licenses.bsd3;
      }) {};
 
+  "BNFC_2_9_1" = callPackage
+    ({ mkDerivation, alex, array, base, Cabal, cabal-doctest
+     , containers, deepseq, directory, doctest, filepath, happy, hspec
+     , hspec-discover, HUnit, mtl, pretty, process, QuickCheck
+     , string-qq, temporary, time
+     }:
+     mkDerivation {
+       pname = "BNFC";
+       version = "2.9.1";
+       sha256 = "0670in07lr9fgkx0c7zci8rn8c7g8nimkmpzy5w9swfp4rp3gbkk";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         array base containers deepseq directory filepath mtl pretty process
+         string-qq time
+       ];
+       libraryToolDepends = [ alex happy ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         array base containers deepseq directory doctest filepath hspec
+         HUnit mtl pretty process QuickCheck string-qq temporary time
+       ];
+       testToolDepends = [ alex happy hspec-discover ];
+       description = "A compiler front-end generator";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "BNFC-meta" = callPackage
     ({ mkDerivation, alex-meta, array, base, fail, happy-meta
      , haskell-src-meta, syb, template-haskell
···
        pname = "Chart";
        version = "1.9.3";
        sha256 = "0p69kq5kh40gd4y8wqabypmw67pqh42vaaw64zv9sf8j075g85ry";
-       revision = "1";
-       editedCabalFile = "1is2xvhwyf5j4nls6k162glazd28jj84r2h0bf868q93qdppzgxj";
+       revision = "2";
+       editedCabalFile = "04mmsm54mdqcrypvgawhhbwjscmky3j7g5841bc71c0q6d33h2k4";
        libraryHaskellDepends = [
          array base colour data-default-class lens mtl old-locale
          operational time vector
···
        pname = "Chart-cairo";
        version = "1.9.3";
        sha256 = "0clm68alzsakkn5m4h49dgx33crajacsykb4hry2fh9zxp9j743f";
-       revision = "1";
-       editedCabalFile = "1jhw93vmhafnrvim03afc989n6jdiwpnwqma09zxd3m09hcsg17l";
+       revision = "2";
+       editedCabalFile = "0z93znn3dpgj80iiz3a67m90x0j9ljr0jd1ws9jkzj7rk88014gp";
        libraryHaskellDepends = [
          array base cairo Chart colour data-default-class lens mtl
          old-locale operational time
···
        pname = "Chart-diagrams";
        version = "1.9.3";
        sha256 = "075yzq50jpakgq6lb3anr660jydm68ry0di33icdacbdymq8avwn";
-       revision = "1";
-       editedCabalFile = "1hm4z73k60ndb5jvy6wxviiyv9i0qd6diz8kf36yfbayzacqianw";
+       revision = "2";
+       editedCabalFile = "00whqmaqrbidicsz9dqvq88jc88m8cixxkyf70qsdg7ysg8dad8m";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base blaze-markup bytestring Chart colour containers
···
        pname = "HaXml";
        version = "1.25.5";
        sha256 = "0d8jbiv53r3ndg76r3937idqdg34nhmb99vj087i73hjnv21mifb";
-       revision = "3";
-       editedCabalFile = "0n98cigikjiqg2ckgihjw4if35n1jhv0zcqi3qw56b9j02yxdvvz";
+       revision = "4";
+       editedCabalFile = "029jnlmab1llr55dmlamrn2hxkbqw7ryz1dfg19h1aip6byf4ljh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
      }) {inherit (pkgs) alsaLib;};
 
+  "PortMidi-simple" = callPackage
+    ({ mkDerivation, base, PortMidi }:
+     mkDerivation {
+       pname = "PortMidi-simple";
+       version = "0.1.0.0";
+       sha256 = "17bl26jlpd48ag42kbjdirqhpahxaiax5sy7p3j1jylhiargijcd";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base PortMidi ];
+       executableHaskellDepends = [ base PortMidi ];
+       description = "Simplified PortMidi wrapper";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "PostgreSQL" = callPackage
     ({ mkDerivation, base, mtl }:
      mkDerivation {
···
        pname = "Win32-errors";
        version = "0.2.2.5";
        sha256 = "08gbvlsf37nx982qs19pb9qc5sxi6493f02d3afjsyxqvalfbijy";
+       revision = "1";
+       editedCabalFile = "0vk991m2b14sqs74fnbxfymp9hzvmn30xkrngkhl6idyqgc0hsbd";
        libraryHaskellDepends = [ base template-haskell text Win32 ];
        testHaskellDepends = [ base hspec QuickCheck Win32 ];
        description = "Alternative error handling for Win32 foreign calls";
···
      }:
      mkDerivation {
        pname = "Z-Data";
-       version = "0.6.1.0";
-       sha256 = "096zzi2fb6pj310bkihsidwaail9hi78mpfplg4c8skq4157ps6s";
+       version = "0.7.0.0";
+       sha256 = "1b4ycsq5g459ynp989kldq6r3ssawr64a2hp3dzy804pwrp8v62m";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          base bytestring case-insensitive containers deepseq ghc-prim
···
        pname = "aeson-compat";
        version = "0.3.9";
        sha256 = "1j13gykv4ryvmr14w5blz0nnpdb4p0hpa27wahw3mhb1lwdr8hz0";
-       revision = "4";
-       editedCabalFile = "0l2ggm3lfnww4sq9frr0cga4ad9vlfhjsh323f9lvx3jk0g9pn7y";
+       revision = "5";
+       editedCabalFile = "11ca16ff12jp0kndhwaq8gm3jc2irs3hbmd1lh2lwrqyq498d8k6";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-iso8601 base base-compat bytestring
          containers exceptions hashable scientific tagged text time
···
        ];
        description = "Extra goodies for aeson";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "aeson-filthy" = callPackage
···
        ];
        description = "Companion library for the book Algebra-Driven Design by Sandy Maguire";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "algebra-sql" = callPackage
···
        broken = true;
      }) {};
 
+  "algorithmic-composition-additional" = callPackage
+    ({ mkDerivation, algorithmic-composition-basic, base, bytestring
+     , directory, foldable-ix, mmsyn2-array, mmsyn3, mmsyn7l
+     , mmsyn7ukr-common, phonetic-languages-simplified-base, process
+     , ukrainian-phonetics-basic-array
+     }:
+     mkDerivation {
+       pname = "algorithmic-composition-additional";
+       version = "0.1.0.0";
+       sha256 = "183zjamprssdn3qiiil2ahzhfj6ajg7zs5vdspjfwfq651r8c9gh";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         algorithmic-composition-basic base bytestring directory foldable-ix
+         mmsyn2-array mmsyn3 mmsyn7l mmsyn7ukr-common
+         phonetic-languages-simplified-base process
+         ukrainian-phonetics-basic-array
+       ];
+       executableHaskellDepends = [
+         algorithmic-composition-basic base bytestring directory foldable-ix
+         mmsyn2-array mmsyn3 mmsyn7l mmsyn7ukr-common
+         phonetic-languages-simplified-base process
+         ukrainian-phonetics-basic-array
+       ];
+       description = "Helps to create experimental music from a file (or its part) and a Ukrainian text";
+       license = lib.licenses.mit;
+     }) {};
+
   "algorithmic-composition-basic" = callPackage
     ({ mkDerivation, base, bytestring, directory, foldable-ix
      , mmsyn2-array, mmsyn3, mmsyn7l, mmsyn7ukr-common
···
      }:
      mkDerivation {
        pname = "algorithmic-composition-basic";
-       version = "0.1.1.0";
-       sha256 = "0sxgysi596j77j3bfadvk6gcq9k70g0wqrq1mgxh4ypmc145psc1";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.2.2.0";
+       sha256 = "0ij3yh29mxkj9zph33g3r46afh3s4vhqxmhkpnm2mgzad7xqca2m";
        libraryHaskellDepends = [
-         base bytestring directory foldable-ix mmsyn2-array mmsyn3 mmsyn7l
-         mmsyn7ukr-common phonetic-languages-simplified-base process
-         ukrainian-phonetics-basic-array
-       ];
-       executableHaskellDepends = [
          base bytestring directory foldable-ix mmsyn2-array mmsyn3 mmsyn7l
          mmsyn7ukr-common phonetic-languages-simplified-base process
          ukrainian-phonetics-basic-array
···
        license = lib.licenses.gpl3;
      }) {};
 
+  "amqp-utils_0_5_0_0" = callPackage
+    ({ mkDerivation, amqp, base, bytestring, connection, containers
+     , data-default-class, directory, hinotify, magic, network, process
+     , text, time, tls, unix, utf8-string, x509-system
+     }:
+     mkDerivation {
+       pname = "amqp-utils";
+       version = "0.5.0.0";
+       sha256 = "140awzxj14h9wa13wfl15dqndqvyy046zmyg0q643r40nbyggl8r";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         amqp base bytestring connection containers data-default-class
+         directory hinotify magic network process text time tls unix
+         utf8-string x509-system
+       ];
+       description = "AMQP toolset for the command line";
+       license = lib.licenses.gpl3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "amqp-worker" = callPackage
     ({ mkDerivation, aeson, amqp, base, bytestring, data-default
      , exceptions, monad-control, monad-loops, mtl, resource-pool
···
      }:
      mkDerivation {
        pname = "arch-hs";
-       version = "0.7.0.0";
-       sha256 = "0nlsxlqmjg0nw9dgd3l8s1zphzcwrbcvmv30s5y5xbfm06zc5wc7";
+       version = "0.7.1.0";
+       sha256 = "120kxjz27llinggq6qwihqjbs1f4q0wdfb79fmrb80k25pvhkn8v";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Arch Linux official and AUR web interface binding";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "archive" = callPackage
···
        pname = "attoparsec";
        version = "0.13.2.5";
        sha256 = "0vv88m5m7ynjrg114psp4j4s69f1a5va3bvn293vymqrma7g7q11";
+       revision = "1";
+       editedCabalFile = "180r53j8z1p6z2l63qmhqyl1h27l5j3vrhanwfmwchrj7xf1k23w";
        libraryHaskellDepends = [
          array base bytestring containers deepseq ghc-prim scientific text
          transformers
···
      }:
      mkDerivation {
        pname = "aur";
-       version = "7.0.5";
-       sha256 = "16c4q0w6qpn4gg6xlggkcs92fcvm58a3qmykfm1dgcfsjhwwhxkx";
-       revision = "1";
-       editedCabalFile = "10p4qyfv2ha3s8dli6v9yzzx4pj5r1cfxcy0gcf0rgbxsszi2315";
+       version = "7.0.6";
+       sha256 = "0rq2gyhg5c7xwj7w582l99al8jhsacv3vl77p1mfzcc79h424jdy";
        libraryHaskellDepends = [
          aeson base bytestring hashable http-client http-types text
        ];
···
      }:
      mkDerivation {
        pname = "aura";
-       version = "3.2.2";
-       sha256 = "07ska8w2k3sl084aadjclw8v0ykrp8hiwhim5zd6wd7q95njyk2f";
-       revision = "2";
-       editedCabalFile = "1m138p8rllm42gpqj10z3jvdlcz9f0v4is4ygdxi7yxn9xmy15x9";
+       version = "3.2.3";
+       sha256 = "1gq4nkwil64h4armg39vbl3wjsbnqsa0vg5b41kq19dp9rmpfsp5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "aws-lambda-haskell-runtime" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, case-insensitive, hspec
-     , http-client, http-types, path, path-io, safe-exceptions-checked
-     , template-haskell, text, unordered-containers
+    ({ mkDerivation, aeson, base, bytestring, case-insensitive
+     , exceptions, hashable, hspec, http-client, http-types, mtl, path
+     , path-io, safe-exceptions-checked, template-haskell, text
+     , unordered-containers
      }:
      mkDerivation {
        pname = "aws-lambda-haskell-runtime";
-       version = "3.0.5";
-       sha256 = "07p0lz2hj17n97f2ps59axb4c6416g45m6wcd3hk7jybd6ja8qpr";
+       version = "4.1.0";
+       sha256 = "1zb426bj1k3b3sp5hlg0ajx19mf0vwvr39zdg6p9l9i830qfdjfw";
        libraryHaskellDepends = [
-         aeson base bytestring case-insensitive http-client http-types path
-         path-io safe-exceptions-checked template-haskell text
-         unordered-containers
+         aeson base bytestring case-insensitive exceptions hashable
+         http-client http-types mtl path path-io safe-exceptions-checked
+         template-haskell text unordered-containers
        ];
        testHaskellDepends = [ base hspec ];
        description = "Haskell runtime for AWS Lambda";
···
      }:
      mkDerivation {
        pname = "aws-lambda-haskell-runtime-wai";
-       version = "1.0.2";
-       sha256 = "0bjqrwl2kcnxv8yni2bxaz5x3pgs3j6c4rrgqpv5kfs7yn1ins7w";
+       version = "2.0.0";
+       sha256 = "1m95hcfl72v9rrks0clzrz3md35jsk5jgc5ds81vrknzxr0b0fgj";
        libraryHaskellDepends = [
          aeson aws-lambda-haskell-runtime base binary bytestring
          case-insensitive http-types iproute network text
···
        ];
        description = "Package Haskell functions for easy use on AWS Lambda";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "aws-mfa-credentials" = callPackage
···
     ({ mkDerivation, base, dec, deepseq, fin, hashable, QuickCheck }:
      mkDerivation {
        pname = "bin";
-       version = "0.1";
-       sha256 = "008i0yxvg9v05gby6ysq3f7ygh125p9xa5vwrcrbq5xw79igyzq5";
-       revision = "2";
-       editedCabalFile = "1zmzi566syvrm9bk0mxj3dycd3i4b33018c644qxdqdb00mlvayh";
+       version = "0.1.1";
+       sha256 = "11awr2zdknjdgy365hh3alq0fjkhhixk6synf65af2brzkl8k5ys";
        libraryHaskellDepends = [
          base dec deepseq fin hashable QuickCheck
        ];
···
        ];
        description = "Binary and exponential searches";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "binary-serialise-cbor" = callPackage
···
      }:
      mkDerivation {
        pname = "bitwise-enum";
-       version = "1.0.0.3";
-       sha256 = "0ykrr8x1hc1lsj8cn19jcypvww4598g1v0vrn3z3b7n6hp6wfyis";
-       revision = "3";
-       editedCabalFile = "19d5xwigd482z47s8gpbd2jmm4pmx5bxg2fxkzjl8dias4yb431x";
-       libraryHaskellDepends = [
-         aeson array base deepseq mono-traversable vector
-       ];
-       testHaskellDepends = [
-         aeson array base deepseq mono-traversable QuickCheck test-framework
-         test-framework-quickcheck2 vector
-       ];
-       benchmarkHaskellDepends = [
-         aeson array base deepseq gauge mono-traversable vector wide-word
-       ];
-       description = "Bitwise operations on bounded enumerations";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "bitwise-enum_1_0_1_0" = callPackage
-    ({ mkDerivation, aeson, array, base, deepseq, gauge
-     , mono-traversable, QuickCheck, test-framework
-     , test-framework-quickcheck2, vector, wide-word
-     }:
-     mkDerivation {
-       pname = "bitwise-enum";
        version = "1.0.1.0";
        sha256 = "0vmdr8csmxwab7s4nmqdfpqdssivh90fddk94i8wkwj1la867y1z";
        libraryHaskellDepends = [
···
        ];
        description = "A blazingly fast markup combinator library for Haskell";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "blaze-markup_0_8_2_8" = callPackage
+    ({ mkDerivation, base, blaze-builder, bytestring, containers, HUnit
+     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "blaze-markup";
+       version = "0.8.2.8";
+       sha256 = "0jd30wg5yz0a97b36zwqg4hv8faifza1n2gys3l1p3fwf9l3zz23";
+       libraryHaskellDepends = [ base blaze-builder bytestring text ];
+       testHaskellDepends = [
+         base blaze-builder bytestring containers HUnit QuickCheck tasty
+         tasty-hunit tasty-quickcheck text
+       ];
+       description = "A blazingly fast markup combinator library for Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "blaze-shields" = callPackage
···
        pname = "boring";
        version = "0.1.3";
        sha256 = "1fljlkzc5016xbq9jykh0wr1mbyfcikh818pp54djws5vm66hh6d";
-       revision = "1";
-       editedCabalFile = "1gn2f035fmn2l56a507x080cl1apddszhlsf6lriwyass4v58mfl";
+       revision = "2";
+       editedCabalFile = "031vricyy2m7hg2hk3bj64lsz55k9qh36s2yfh09pgsfykr883ag";
        libraryHaskellDepends = [
          adjunctions base base-compat bin constraints dec fin generics-sop
          ral singleton-bool streams tagged transformers transformers-compat
···
        pname = "cassava";
        version = "0.5.2.0";
        sha256 = "01h1zrdqb313cjd4rqm1107azzx4czqi018c2djf66a5i7ajl3dk";
-       revision = "2";
-       editedCabalFile = "1y08lhkh6c6421g3nwwkrrv3r36l75x9j2hnm5khagjpm5njjzma";
+       revision = "3";
+       editedCabalFile = "0hq9s6662ykk2ldv222xgifwzwvmhmrs56b1llqpdzp7vf7p8b3p";
        configureFlags = [ "-f-bytestring--lt-0_10_4" ];
        libraryHaskellDepends = [
          array attoparsec base bytestring containers deepseq hashable Only
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "citeproc_0_3_0_8" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring
+     , case-insensitive, containers, data-default, Diff, directory
+     , file-embed, filepath, mtl, pandoc-types, pretty, rfc5051, safe
+     , scientific, text, timeit, transformers, uniplate, vector
+     , xml-conduit
+     }:
+     mkDerivation {
+       pname = "citeproc";
+       version = "0.3.0.8";
+       sha256 = "0njlb37cxnpikwz9k92d689j477fz9x7chl58s3ljsw9drcgpcvh";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring case-insensitive containers
+         data-default file-embed filepath pandoc-types rfc5051 safe
+         scientific text transformers uniplate vector xml-conduit
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers Diff directory filepath mtl pretty
+         text timeit transformers
+       ];
+       description = "Generates citations and bibliography from CSL styles";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "citeproc-hs" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
      , hexpat, hs-bibutils, HTTP, json, mtl, network, network-uri
···
        license = lib.licenses.mit;
      }) {};
 
+  "conduit_1_3_4_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, directory
+     , exceptions, filepath, gauge, hspec, kan-extensions
+     , mono-traversable, mtl, mwc-random, primitive, QuickCheck
+     , resourcet, safe, silently, split, text, transformers, unix
+     , unliftio, unliftio-core, vector
+     }:
+     mkDerivation {
+       pname = "conduit";
+       version = "1.3.4.1";
+       sha256 = "1w96q9nqxvl1s9js1rrzy9x711jpkj8mm6s5nz67jmrdby6knx45";
+       libraryHaskellDepends = [
+         base bytestring directory exceptions filepath mono-traversable mtl
+         primitive resourcet text transformers unix unliftio-core vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory exceptions filepath hspec
+         mono-traversable mtl QuickCheck resourcet safe silently split text
+         transformers unliftio vector
+       ];
+       benchmarkHaskellDepends = [
+         base containers deepseq gauge hspec kan-extensions mwc-random
+         transformers vector
+       ];
+       description = "Streaming data processing library";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "conduit-algorithms" = callPackage
     ({ mkDerivation, async, base, bytestring, bzlib-conduit, conduit
      , conduit-combinators, conduit-extra, conduit-zstd, containers
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "conferer_1_1_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, directory
+     , filepath, hspec, QuickCheck, text
+     }:
+     mkDerivation {
+       pname = "conferer";
+       version = "1.1.0.0";
+       sha256 = "1hkdrqxrac1mbzvd29f6ds4cbihdv0j0daai7yc282myv0varh09";
+       libraryHaskellDepends = [
+         base bytestring containers directory filepath text
+       ];
+       testHaskellDepends = [
+         base bytestring containers deepseq directory filepath hspec
+         QuickCheck text
+       ];
+       description = "Configuration management library";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "conferer-aeson" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, bytestring, conferer
      , directory, hspec, text, unordered-containers, vector
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "conferer-aeson_1_1_0_0" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, base, bytestring, conferer
+     , directory, hspec, text, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "conferer-aeson";
+       version = "1.1.0.0";
+       sha256 = "0kslxj2wcycygj07x7v06fcx2i47dwp96da9djws6mjdmr1a9i96";
+       libraryHaskellDepends = [
+         aeson base bytestring conferer directory text unordered-containers
+         vector
+       ];
+       testHaskellDepends = [
+         aeson aeson-qq base bytestring conferer directory hspec text
+         unordered-containers vector
+       ];
+       description = "conferer's source for reading json files";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "conferer-dhall" = callPackage
     ({ mkDerivation, base, bytestring, conferer, conferer-aeson, dhall
      , dhall-json, directory, hspec, text
      }:
      mkDerivation {
        pname = "conferer-dhall";
-       version = "1.0.0.0";
-       sha256 = "0xw2c1cmjw93x4ala85bxs0lfwlqwdl26lj1n7yc9lk67ln54912";
+       version = "1.1.0.0";
+       sha256 = "0whxxjz5askw1qxcxdn5094bqm2hy3zp49567v57gqikgv6rcnp1";
        libraryHaskellDepends = [
          base bytestring conferer conferer-aeson dhall dhall-json directory
          text
···
     ({ mkDerivation, base, conferer, conferer-aeson, hspec, yaml }:
      mkDerivation {
        pname = "conferer-yaml";
-       version = "1.0.0.0";
-       sha256 = "091pkbkjpppkc2ygm8jq22xslr4afbp3kk5377gpx3vh4a0lvswg";
+       version = "1.1.0.0";
+       sha256 = "0pqxwwaskj96virs65p7cb6shkjbczmnqwla7rbfga2l0rw9ww0r";
        libraryHaskellDepends = [ base conferer conferer-aeson yaml ];
        testHaskellDepends = [ base conferer conferer-aeson hspec yaml ];
        description = "Configuration for reading yaml files";
···
      }:
      mkDerivation {
        pname = "cql";
-       version = "4.0.2";
-       sha256 = "0b6806ahmg4yacx5wc4v53gihhkwywajhqm13kb11nxabww3lapl";
+       version = "4.0.3";
+       sha256 = "1b6bqhg3rf2kk7i81l4vsgyp7zxiycifdrsj8qa4sqx78m72dmxh";
        libraryHaskellDepends = [
          base bytestring cereal containers Decimal iproute network
          template-haskell text time transformers uuid vector
···
        ];
        description = "A simple tool for comparing in Criterion benchmark results";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "criterion-compare" = callPackage
···
        description = "bindings to libcurl, the multiprotocol file transfer library";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "curly-expander" = callPackage
+     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+     mkDerivation {
+       pname = "curly-expander";
+       version = "0.2.0.3";
+       sha256 = "0sfd3vmkx74fp1yvbwwbx4rw3i1g70hcvcp205mz709r8yyhr9sb";
+       libraryHaskellDepends = [ base parsec text ];
+       testHaskellDepends = [ base parsec text ];
+       description = "Curly braces (brackets) expanding";
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "currencies" = callPackage
···
        license = lib.licenses.asl20;
      }) {};
 
-  "dbus_1_2_19" = callPackage
+  "dbus_1_2_21" = callPackage
     ({ mkDerivation, base, bytestring, cereal, conduit, containers
      , criterion, deepseq, directory, exceptions, extra, filepath, lens
      , network, parsec, process, QuickCheck, random, resourcet, split
···
      }:
      mkDerivation {
        pname = "dbus";
-       version = "1.2.19";
-       sha256 = "1wcwh8c27v8vs7jaqzp3032wzx14v4mn7r2qhxhb77cppimrjqpg";
+       version = "1.2.21";
+       sha256 = "023lfywmxc5qqb31jaxpcf319az8ma9k9b0lkgriklskacq9sadi";
        libraryHaskellDepends = [
          base bytestring cereal conduit containers deepseq exceptions
          filepath lens network parsec random split template-haskell text
···
        license = lib.licenses.mit;
      }) {};
 
+  "deferred-folds_0_9_17" = callPackage
+    ({ mkDerivation, base, bytestring, containers, foldl, hashable
+     , primitive, QuickCheck, quickcheck-instances, rerebase, tasty
+     , tasty-hunit, tasty-quickcheck, text, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "deferred-folds";
+       version = "0.9.17";
+       sha256 = "1dn7ylqsqrc5s734xc4bsif6f53hg84i8w7zi929pikjl7xkbrch";
+       libraryHaskellDepends = [
+         base bytestring containers foldl hashable primitive text
+         transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       description = "Abstractions over deferred folds";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "definitive-base" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, deepseq
      , ghc-prim, GLURaw, OpenGL, OpenGLRaw, primitive, vector
···
        ];
        description = "Reader-like monad transformer for dependency injection";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "dep-t-advice" = callPackage
···
        ];
        description = "Giving good advice to functions in a DepT environment";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "dependency" = callPackage
···
        ];
        description = "Convert recursive ADTs from and to Dhall";
        license = lib.licenses.cc0;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "dhall-text" = callPackage
···
        ];
        description = "Vinyl-based records with hierarchical field names, default values and documentation";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "docstrings" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
-  "doctest_0_18" = callPackage
+  "doctest_0_18_1" = callPackage
     ({ mkDerivation, base, base-compat, code-page, deepseq, directory
-     , filepath, ghc, ghc-paths, hspec, hspec-core, HUnit, mockery
-     , process, QuickCheck, setenv, silently, stringbuilder, syb
-     , transformers
+     , exceptions, filepath, ghc, ghc-paths, hspec, hspec-core, HUnit
+     , mockery, process, QuickCheck, setenv, silently, stringbuilder
+     , syb, transformers
      }:
      mkDerivation {
        pname = "doctest";
-       version = "0.18";
-       sha256 = "1yqrmjg3rn1vy0p6a6j78gnnl8lx4hzi0rwhpl5ljb4q6kzyc3x4";
+     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+       sha256 = "07w77cik8p3kpcl5vx4l3cr93r1dhk3wc98k1g50l9pby5argrzb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base base-compat code-page deepseq directory filepath ghc ghc-paths
-         process syb transformers
+         base base-compat code-page deepseq directory exceptions filepath
+         ghc ghc-paths process syb transformers
        ];
        executableHaskellDepends = [
-         base base-compat code-page deepseq directory filepath ghc ghc-paths
-         process syb transformers
+         base base-compat code-page deepseq directory exceptions filepath
+         ghc ghc-paths process syb transformers
        ];
        testHaskellDepends = [
-         base base-compat code-page deepseq directory filepath ghc ghc-paths
-         hspec hspec-core HUnit mockery process QuickCheck setenv silently
-         stringbuilder syb transformers
+         base base-compat code-page deepseq directory exceptions filepath
+         ghc ghc-paths hspec hspec-core HUnit mockery process QuickCheck
+         setenv silently stringbuilder syb transformers
        ];
        description = "Test interactive Haskell examples";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, doctest }:
      mkDerivation {
        pname = "doctest-driver-gen";
-       version = "0.3.0.2";
-       sha256 = "1xkq9fpdm8ayjwf2lypkfnh1w08zimvhf27ffn71hfckd5nw4h2q";
+       version = "0.3.0.3";
+       sha256 = "0vb062mznjpksrbsf2v599slgnm5jr6dq1frbxii19mcqxjbnzrj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
···
      }:
      mkDerivation {
        pname = "dormouse-client";
-       version = "0.1.0.1";
-       sha256 = "033299c0rc6hsg51pg7igb5fnf8w200ckazmyjk23d1h48mz7gcg";
+       version = "0.2.0.0";
+       sha256 = "1l5vhlvl5kl4m5shl2rysj16r7wqkqwy1i1yb3r96zx8rbwhi2j8";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring case-insensitive containers
          dormouse-uri http-api-data http-client http-client-tls http-types
···
      }:
      mkDerivation {
        pname = "dormouse-uri";
-       version = "0.1.0.1";
-       sha256 = "04ps9k4dhg9xk7al12y757lxl45dfa0aczirdkyks28cavlpr07b";
+       version = "0.2.0.0";
+       sha256 = "1b19167xprw9f4ivpfl0sdk2gs2ai6jxk25wyy7xlvzq2fn5q6sd";
        libraryHaskellDepends = [
          attoparsec base bytestring case-insensitive containers http-types
          safe-exceptions template-haskell text
···
        ];
        description = "Bindings to libevdev";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) libevdev;};
 
   "evdev-streamly" = callPackage
···
        ];
        description = "Bridge for working with evdev and streamly";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "eve" = callPackage
···
        ];
        description = "A library for crawling exhentai";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "exhaustive" = callPackage
···
      }) {};
 
   "faktory" = callPackage
-    ({ mkDerivation, aeson, aeson-casing, base, bytestring, connection
-     , cryptonite, hspec, markdown-unlit, megaparsec, memory, network
-     , random, safe-exceptions, scanner, text, time, unix
+    ({ mkDerivation, aeson, aeson-casing, async, base, bytestring
+     , connection, cryptonite, hspec, markdown-unlit, megaparsec, memory
+     , mtl, network, random, safe-exceptions, scanner, semigroups, text
+     , time, unix, unordered-containers
      }:
      mkDerivation {
        pname = "faktory";
-       version = "1.0.1.6";
-       sha256 = "1yqld2b6lbxl9sw9yp3dy184189nhfs7q4shnyrzc0m000hxgwkj";
+       version = "1.0.2.0";
+       sha256 = "1i16g4sj5qrbyldyylggcammr2fs0dvi9hc986ijpv3iy0ryqkmw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-casing base bytestring connection cryptonite megaparsec
-         memory network random safe-exceptions scanner text time unix
+         memory mtl network random safe-exceptions scanner semigroups text
+         time unix unordered-containers
        ];
        executableHaskellDepends = [ aeson base safe-exceptions ];
-       testHaskellDepends = [ aeson base hspec markdown-unlit ];
+       testHaskellDepends = [
+         aeson async base hspec markdown-unlit time
+       ];
        testToolDepends = [ markdown-unlit ];
        description = "Faktory Worker for Haskell";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "fbrnch";
-       version = "0.7.1";
-       sha256 = "05gs3r9c67xvpkpg968aj0ym39qakazbycjlb8wnys5ijc0iwa7w";
+       version = "0.7.2";
+       sha256 = "1xly3vjd8ylxwnc16y6hcrbg1chr4cxx60f3i3r9cyv1vrvf7l1k";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "fin" = callPackage
     ({ mkDerivation, base, dec, deepseq, hashable, inspection-testing
-     , QuickCheck, tagged
+     , QuickCheck, tagged, universe-base
      }:
      mkDerivation {
        pname = "fin";
-       version = "0.1.1";
-       sha256 = "0zwc8x2ilbk1bhsk85brf6g300cx4w2j3602gjh6rv900961gqri";
-       revision = "2";
-       editedCabalFile = "1x446k44pci81dakzd98vrj6amj10xkb05k7g2qwk0ir1hdj5sfz";
-       libraryHaskellDepends = [ base dec deepseq hashable QuickCheck ];
+       version = "0.2";
+       sha256 = "1xy3dgvl6s4cyb0l2hkyl06nbhc4dpc3sy2kjd8w7av9921k96i3";
+       libraryHaskellDepends = [
+         base dec deepseq hashable QuickCheck universe-base
+       ];
        testHaskellDepends = [ base inspection-testing tagged ];
        description = "Nat and Fin: peano naturals and finite numbers";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "fold-debounce-conduit" = callPackage
-    ({ mkDerivation, base, conduit, fold-debounce, hspec, resourcet
-     , stm, transformers, transformers-base
+    ({ mkDerivation, base, conduit, fold-debounce, hspec
+     , hspec-discover, resourcet, stm, transformers, transformers-base
      }:
      mkDerivation {
        pname = "fold-debounce-conduit";
-       version = "0.2.0.5";
-       sha256 = "1qvr3wqqv2lvs22ddmalavggp8a4a50d056a50dsz6lcml1k6hdg";
+       version = "0.2.0.6";
+       sha256 = "0xy6vr2hbw41fcs3rlk7wyxqrkqd3nfw5rcr1aiij86zaaifpry5";
        libraryHaskellDepends = [
          base conduit fold-debounce resourcet stm transformers
          transformers-base
···
        testHaskellDepends = [
          base conduit hspec resourcet stm transformers
        ];
+       testToolDepends = [ hspec-discover ];
        description = "Regulate input traffic from conduit Source with Control.FoldDebounce";
        license = lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "foldl";
-       version = "1.4.10";
-       sha256 = "1fl1vahga6dv21nkgjd265nlhmgqzr8sa0fb5dfqzk34fb01vvvq";
-       revision = "1";
-       editedCabalFile = "0rd3w7m8a8pxb8jpmi9nky4hf1jl35cm8vp1qq8mfzgpx5bbqd2w";
-       libraryHaskellDepends = [
-         base bytestring comonad containers contravariant hashable
-         mwc-random primitive profunctors semigroupoids text transformers
-         unordered-containers vector
-       ];
-       testHaskellDepends = [ base doctest ];
-       benchmarkHaskellDepends = [ base criterion ];
-       description = "Composable, streaming, and efficient left folds";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "foldl_1_4_11" = callPackage
-    ({ mkDerivation, base, bytestring, comonad, containers
-     , contravariant, criterion, doctest, hashable, mwc-random
-     , primitive, profunctors, semigroupoids, text, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "foldl";
        version = "1.4.11";
        sha256 = "05i87pqldk1xfpx66nh1lhn75x3g7s8kvhf9k9yll33a6ggawwxl";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "Composable, streaming, and efficient left folds";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "foldl-exceptions" = callPackage
···
   "fortran-src" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, fgl, filepath, GenericPretty, happy, hspec
-     , mtl, pretty, text, uniplate
+     , hspec-discover, mtl, pretty, temporary, text, uniplate
      }:
      mkDerivation {
        pname = "fortran-src";
-       version = "0.4.0";
-       sha256 = "1l66f9wcn5dp7i63wapzkx8bgiy22xrlxbfh3jbnhy7glhvk80ja";
+       version = "0.4.2";
+       sha256 = "03x1pxkpl41r4cf034qj5ls946azbzwdyxkp2nxxymjx0nm2lsv6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory fgl
-         filepath GenericPretty mtl pretty text uniplate
+         filepath GenericPretty mtl pretty temporary text uniplate
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [
          array base binary bytestring containers deepseq directory fgl
-         filepath GenericPretty mtl pretty text uniplate
+         filepath GenericPretty mtl pretty temporary text uniplate
        ];
        testHaskellDepends = [
          array base binary bytestring containers deepseq directory fgl
-         filepath GenericPretty hspec mtl pretty text uniplate
+         filepath GenericPretty hspec mtl pretty temporary text uniplate
        ];
-       description = "Parser and anlyses for Fortran standards 66, 77, 90 and 95";
+       testToolDepends = [ hspec-discover ];
+       description = "Parsers and analyses for Fortran standards 66, 77, 90 and 95";
        license = lib.licenses.asl20;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
        libraryHaskellDepends = [ base ShowF type-unary ];
        description = "Depth-typed functor-based trees, both top-down and bottom-up";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "ftshell" = callPackage
···
        ];
        description = "Functor combinators with tries & zippers";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "functor-friends" = callPackage
···
 
   "futhark" = callPackage
     ({ mkDerivation, aeson, alex, ansi-terminal, array, base, binary
-     , blaze-html, bytestring, bytestring-to-vector, cmark-gfm
+     , blaze-html, bmp, bytestring, bytestring-to-vector, cmark-gfm
      , containers, directory, directory-tree, dlist, file-embed
      , filepath, free, gitrev, happy, haskeline, language-c-quote
      , mainland-pretty, megaparsec, mtl, neat-interpolation, parallel
···
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.18.6";
-       sha256 = "0bp837b6myis5kvyy0rg3py01fcyyj7qws7kqvci3mjyi9x57k7w";
+       version = "0.19.1";
+       sha256 = "1nhy1pjqy7na7brpkh72yzcglfrwaz7l325fivfq5niaq85832dd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson ansi-terminal array base binary blaze-html bytestring
+         aeson ansi-terminal array base binary blaze-html bmp bytestring
          bytestring-to-vector cmark-gfm containers directory directory-tree
          dlist file-embed filepath free gitrev haskeline language-c-quote
          mainland-pretty megaparsec mtl neat-interpolation parallel
···
        ];
        description = "An optimising compiler for a functional, array-oriented language";
        license = lib.licenses.isc;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "futhask" = callPackage
···
        ];
        description = "A barebones textboard for the Gemini protocol";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gemstone" = callPackage
···
        testHaskellDepends = [ base Cabal inspection-testing ];
        description = "Generically extract and replace collections of record fields";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "generic-lens" = callPackage
···
        pname = "generic-lens-lite";
        version = "0.1";
        sha256 = "07z00phy6h50bb4axlr57kin9l5fygi4q4j33rj5180ai2cbcpc6";
-       revision = "1";
-       editedCabalFile = "1gbl0kmc77yjvn63cgdsifhzyd54g1v1qq1pjsrhhn0hb4c8jszz";
+       revision = "2";
+       editedCabalFile = "0516sqr5xplh57kdzcxx1fpsxwhmxc1bl9hxlcdif9hrjjb61rwg";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        description = "Monomorphic field lens like with generic-lens";
···
        pname = "generic-optics-lite";
        version = "0.1";
        sha256 = "0vf5sk1narj69pdhjqxjj0w3w3i5lxjxn8p98xp8dj0jws4mx9xi";
-       revision = "1";
-       editedCabalFile = "1z6bglkw2lvwlxjs0dlmr9wa4rh73pkzhqlg5dq88q5p9d51cy09";
+       revision = "2";
+       editedCabalFile = "1ib6klb9ff27qw8y6icywldnq1p5z8fbkwkibsjyimbvvdk4lqki";
        libraryHaskellDepends = [ base generic-lens-lite optics-core ];
        testHaskellDepends = [ base optics-core ];
        description = "Monomorphic field opics like with generic-lens";
···
      }) {};
 
   "ghc-trace-events" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, text }:
-     mkDerivation {
-       pname = "ghc-trace-events";
-       version = "0.1.2.1";
-       sha256 = "0isxvysjk8z9ya8kbjkbp95wf7b4ixk0bjjy831aqyl6kbrnps84";
-       libraryHaskellDepends = [ base bytestring text ];
-       benchmarkHaskellDepends = [ base bytestring criterion ];
-       description = "Faster traceEvent and traceMarker, and binary object logging for eventlog";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ghc-trace-events_0_1_2_2" = callPackage
     ({ mkDerivation, base, bytestring, tasty-bench, text }:
      mkDerivation {
        pname = "ghc-trace-events";
···
        benchmarkHaskellDepends = [ base bytestring tasty-bench ];
        description = "Faster traceEvent and traceMarker, and binary object logging for eventlog";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-typelits-extra" = callPackage
···
        broken = true;
      }) {shake-bench = null;};
 
-  "ghcide_0_7_5_0" = callPackage
+  "ghcide_1_0_0_0" = callPackage
     ({ mkDerivation, aeson, array, async, base, base16-bytestring
      , binary, bytestring, bytestring-encoding, case-insensitive
      , containers, cryptohash-sha1, data-default, deepseq, dependent-map
···
      }:
      mkDerivation {
        pname = "ghcide";
-       version = "0.7.5.0";
-       sha256 = "157h7jliwf25yjip9hfc5lghifqgqz3ckj894fnmx7pw4jfwyc2s";
+       version = "1.0.0.0";
+       sha256 = "15hz49d68229bnp8g7q1ac60ryd4zbyc1rbxsfaq5lb586ps82k8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "group-theory" = callPackage
-    ({ mkDerivation, base, Cabal, cabal-doctest, containers, doctest
-     , groups
-     }:
+    ({ mkDerivation, base, containers, groups }:
      mkDerivation {
        pname = "group-theory";
-       version = "0.2.0.0";
-       sha256 = "0giwyvki83ndxn9vyfzi5fkz23c95zv5x09ya1in4i8318f8d7az";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       version = "0.2.1.0";
+       sha256 = "11cm59l3g831pz0h5qr94rf1g7km4bn0gqrb8ikssf4xwnjxib46";
        libraryHaskellDepends = [ base containers groups ];
-       testHaskellDepends = [ base doctest ];
        description = "The theory of groups";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "group-with" = callPackage
···
     ({ mkDerivation, base, filepath, haddock-api }:
      mkDerivation {
        pname = "haddock";
-       version = "2.24.0";
-       sha256 = "08hbn6i6rac8c1l80dfnv9161gh8rs7npdxyk87wqz910h6f4iip";
+       version = "2.25.0";
+       sha256 = "0wjp13f7206g3j2g3lr4msf1anbhjqy9wbgfx382dnanxy80yr74";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haddock-api ];
···
 
   "haddock-api" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, deepseq
-     , directory, filepath, ghc, ghc-boot, ghc-paths, haddock-library
-     , hspec, hspec-discover, QuickCheck, transformers, xhtml
+     , directory, exceptions, filepath, ghc, ghc-boot, ghc-paths
+     , haddock-library, hspec, hspec-discover, mtl, QuickCheck
+     , transformers, xhtml
      }:
      mkDerivation {
        pname = "haddock-api";
-       version = "2.24.0";
-       sha256 = "0bbyhwyshafzcfbzjyv1b09lb8bxcimpj3b605pw5gssxgjh1s8i";
+       version = "2.25.0";
+       sha256 = "1f0gbdlr2kvwagni3416q8jhhjh1b3h1cda5znlmgwdcg9bmcr17";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         array base bytestring containers deepseq directory filepath ghc
-         ghc-boot ghc-paths haddock-library transformers xhtml
+         array base bytestring containers deepseq directory exceptions
+         filepath ghc ghc-boot ghc-paths haddock-library mtl transformers
+         xhtml
        ];
        testHaskellDepends = [
-         array base bytestring containers deepseq directory filepath ghc
-         ghc-boot ghc-paths haddock-library hspec QuickCheck transformers
-         xhtml
+         array base bytestring containers deepseq directory exceptions
+         filepath ghc ghc-boot ghc-paths haddock-library hspec mtl
+         QuickCheck transformers xhtml
        ];
        testToolDepends = [ hspec-discover ];
        description = "A documentation-generation tool for Haskell libraries";
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "haddock-library_1_10_0" = callPackage
+    ({ mkDerivation, base, base-compat, bytestring, containers, deepseq
+     , directory, filepath, hspec, hspec-discover, optparse-applicative
+     , parsec, QuickCheck, text, transformers, tree-diff
+     }:
+     mkDerivation {
+       pname = "haddock-library";
+       version = "1.10.0";
+       sha256 = "15ak06q8yp11xz1hwr0sg2jqi3r78p1n89ik05hicqvxl3awf1pq";
+       libraryHaskellDepends = [
+         base bytestring containers parsec text transformers
+       ];
+       testHaskellDepends = [
+         base base-compat bytestring containers deepseq directory filepath
+         hspec optparse-applicative parsec QuickCheck text transformers
+         tree-diff
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Library exposing some functionality of Haddock";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "haddock-test" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, directory, filepath
      , process, syb, xhtml, xml
···
        license = lib.licenses.gpl3;
      }) {};
 
+  "hadolint_1_23_0" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, colourista
+     , containers, cryptonite, deepseq, directory, filepath, gitrev
+     , hspec, HsYAML, HUnit, ilist, language-docker, megaparsec, mtl
+     , optparse-applicative, parallel, ShellCheck, split, text, void
+     }:
+     mkDerivation {
+       pname = "hadolint";
+       version = "1.23.0";
+       sha256 = "09aaxdi1g199cgaxvv5v2cynvd8rm91mnpaw2a5ppbzc7cgh6rca";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson async base bytestring colourista containers cryptonite
+         deepseq directory filepath HsYAML ilist language-docker megaparsec
+         mtl parallel ShellCheck split text void
+       ];
+       executableHaskellDepends = [
+         base containers gitrev language-docker megaparsec
+         optparse-applicative text
+       ];
+       testHaskellDepends = [
+         aeson base bytestring hspec HsYAML HUnit language-docker megaparsec
+         ShellCheck split text
+       ];
+       description = "Dockerfile Linter JavaScript API";
+       license = lib.licenses.gpl3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hadoop-formats" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, filepath, snappy
      , text, vector
···
 
   "harg" = callPackage
     ({ mkDerivation, aeson, barbies, base, bytestring, directory
-     , higgledy, markdown-unlit, optparse-applicative, split, text, yaml
+     , higgledy, optparse-applicative, split, text, yaml
      }:
      mkDerivation {
        pname = "harg";
-       version = "0.4.2.1";
-       sha256 = "0fbbf9zxfbyc6mnsybrd81sd87ps6qwks5zv5kmjygc6w8ngh6vh";
+       version = "0.5.0.0";
+       sha256 = "1panniqhyg8my7nac569fl6rgdg4bch8x469lsp2r00wwp0sivcs";
        libraryHaskellDepends = [
          aeson barbies base bytestring directory higgledy
          optparse-applicative split text yaml
        ];
-       testHaskellDepends = [
-         aeson barbies base higgledy optparse-applicative
-       ];
-       testToolDepends = [ markdown-unlit ];
+       testHaskellDepends = [ base ];
        description = "Haskell program configuration using higher kinded data";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        libraryToolDepends = [ c2hs ];
        description = "Distributed parallel programming in Haskell using MPI";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {open-pal = null; open-rte = null; openmpi = null;};
 
   "haskell-names" = callPackage
···
      }:
      mkDerivation {
        pname = "haskell-src-meta";
-       version = "0.8.5";
-       sha256 = "1csqp3n7330rhia9msyw34z7qwwj64gdy5qlv8w4jbm49dap24ik";
-       revision = "1";
-       editedCabalFile = "00znr8mrlbyn0n1bw4c82rv82pq5ngkk7kw9cgk13pghf93hwwv7";
+       version = "0.8.7";
+       sha256 = "1yy2dfb1ip1zqx3xh28g92209555abzvxrxiwcl95j27zzqxc6in";
        libraryHaskellDepends = [
          base haskell-src-exts pretty syb template-haskell th-orphans
        ];
···
      }:
      mkDerivation {
        pname = "haskus-utils-data";
-       version = "1.3";
-       sha256 = "0373bb3aqbrw6prn323vy47qq9mfnvmm1lbd9ql1dxgb9px338qn";
+       version = "1.4";
+       sha256 = "18k8kbfy60l60pzc3c3kwny87avwp6sn766cg4b0z47hx8d70i5k";
        libraryHaskellDepends = [
          base containers ghc-prim haskus-utils-types mtl recursion-schemes
          transformers
···
      }:
      mkDerivation {
        pname = "haskus-utils-variant";
-       version = "3.0";
-       sha256 = "128i47aqp1h8j4yganj7l8svdb1ax5vx9h4j55k56wh5yxrg5aan";
+       version = "3.1";
+       sha256 = "0iqlc6lrgrwjqvgpbvvvna8v5daxgf84vnqlgbchy87p67lkv6ni";
        libraryHaskellDepends = [
          base deepseq exceptions haskus-utils-data haskus-utils-types
          template-haskell transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "headroom_0_4_0_0" = callPackage
+    ({ mkDerivation, aeson, base, doctest, either, file-embed
+     , generic-data, hspec, hspec-discover, microlens, microlens-th, mtl
+     , mustache, optparse-applicative, pcre-heavy, pcre-light
+     , QuickCheck, rio, string-interpolate, template-haskell, time, yaml
+     }:
+     mkDerivation {
+       pname = "headroom";
+       version = "0.4.0.0";
+       sha256 = "1xjm84k6wpi7b5w9pjf1siwy4c59rfsgmrg5cbjhznrv8mzvpygw";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base either file-embed generic-data microlens microlens-th
+         mtl mustache optparse-applicative pcre-heavy pcre-light rio
+         string-interpolate template-haskell time yaml
+       ];
+       executableHaskellDepends = [ base optparse-applicative rio ];
+       testHaskellDepends = [
+         aeson base doctest hspec mtl optparse-applicative pcre-light
+         QuickCheck rio string-interpolate time
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "License Header Manager";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "heap" = callPackage
     ({ mkDerivation, base, QuickCheck }:
      mkDerivation {
···
        ];
        description = "Hedgehog will eat your typeclass bugs";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hedgehog-corpus" = callPackage
···
        maintainers = with lib.maintainers; [ roberth ];
      }) {};
 
+  "hercules-ci-cnix-store" = callPackage
+    ({ mkDerivation, base, boost, bytestring, conduit, containers
+     , inline-c, inline-c-cpp, nix, protolude, unliftio-core
+     }:
+     mkDerivation {
+       pname = "hercules-ci-cnix-store";
+       version = "0.1.0.0";
+       sha256 = "1ni83x2453ii2xgq4ihhr41jbjhgga5dq5q8560f555fwrw10brz";
+       libraryHaskellDepends = [
+         base bytestring conduit containers inline-c inline-c-cpp protolude
+         unliftio-core
+       ];
+       librarySystemDepends = [ boost ];
+       libraryPkgconfigDepends = [ nix ];
+       description = "Haskell bindings for Nix's libstore";
+       license = lib.licenses.asl20;
+     }) {inherit (pkgs) boost; inherit (pkgs) nix;};
+
   "here" = callPackage
     ({ mkDerivation, base, haskell-src-meta, mtl, parsec
      , template-haskell
···
      }) {};
 
   "hex-text" = callPackage
-    ({ mkDerivation, base, base16-bytestring, bytestring, doctest, text
-     }:
+    ({ mkDerivation, base, base16-bytestring, bytestring, text }:
      mkDerivation {
        pname = "hex-text";
-       version = "0.1.0.2";
-       sha256 = "0wgqm1ziblgljrh679i44gvdq7bqym37y1lnnpb1mk7qlv664c9h";
+       version = "0.1.0.4";
+       sha256 = "03nlm2axcb29jlx797krfac65fb2f3xbcw7lp3klrnznkagb8884";
        libraryHaskellDepends = [ base base16-bytestring bytestring text ];
-       testHaskellDepends = [ base doctest ];
+       testHaskellDepends = [ base bytestring text ];
        description = "ByteString-Text hexidecimal conversions";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "hextream";
-       version = "0.2.0.0";
-       sha256 = "045q4glzqdl79w4baq4yvqjiqaih48p2iixkb3dv96nwmgr8xl8r";
+       version = "0.3.0.0";
+       sha256 = "05i479zv5j0fyd9nr4c0pgrfkvyngvvw54lqipvzwdkccljs17i8";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base base-compat containers parsers text
···
 
   "hgeometry" = callPackage
     ({ mkDerivation, aeson, base, bifunctors, bytestring, containers
-     , data-clist, deepseq, dlist, doctest, doctest-discover, fingertree
-     , fixed-vector, hashable, hgeometry-combinatorial, hspec, lens
-     , linear, MonadRandom, mtl, primitive, QuickCheck
+     , data-clist, deepseq, deepseq-generics, dlist, doctest
+     , doctest-discover, fingertree, fixed-vector, hashable
+     , hgeometry-combinatorial, hspec, lens, linear, MonadRandom, mtl
+     , nonempty-vector, optparse-applicative, primitive, QuickCheck
      , quickcheck-instances, random, reflection, semigroupoids
-     , semigroups, template-haskell, text, vector, vector-builder, vinyl
-     , yaml
+     , semigroups, tasty-bench, template-haskell, text, vector
+     , vector-algorithms, vector-builder, vector-circular, vinyl, yaml
      }:
      mkDerivation {
        pname = "hgeometry";
-       version = "0.11.0.0";
-       sha256 = "1vbj26j06byz9x0c03q5k7fijl31hsi7x9f5wfr2w9g96d7zl3ls";
-       enableSeparateDataOutput = true;
+       version = "0.12.0.1";
+       sha256 = "12qd960njarmsy1a9b6w6jkjqb05xvmg5261n1xhx3lf70xvffj2";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
          aeson base bifunctors bytestring containers data-clist deepseq
          dlist fingertree fixed-vector hashable hgeometry-combinatorial
-         hspec lens linear MonadRandom mtl primitive QuickCheck
-         quickcheck-instances random reflection semigroupoids semigroups
-         template-haskell text vector vector-builder vinyl yaml
+         hspec lens linear MonadRandom mtl nonempty-vector primitive
+         QuickCheck quickcheck-instances random reflection semigroupoids
+         semigroups template-haskell text vector vector-algorithms
+         vector-builder vector-circular vinyl yaml
        ];
-       testHaskellDepends = [ base doctest doctest-discover QuickCheck ];
+       testHaskellDepends = [
+         base doctest doctest-discover QuickCheck quickcheck-instances
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring containers deepseq deepseq-generics dlist
+         fixed-vector hashable hgeometry-combinatorial lens linear
+         MonadRandom mtl optparse-applicative QuickCheck semigroupoids
+         semigroups tasty-bench vector vector-circular vinyl
+       ];
        description = "Geometric Algorithms, Data structures, and Data types";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hgeometry-combinatorial" = callPackage
-    ({ mkDerivation, aeson, approximate-equality, base, bifunctors
-     , bytestring, containers, contravariant, data-clist, deepseq
-     , directory, dlist, doctest, filepath, fingertree, hashable, hspec
-     , hspec-discover, lens, linear, MonadRandom, mtl, primitive
-     , QuickCheck, quickcheck-instances, random, reflection
-     , semigroupoids, semigroups, singletons, template-haskell, text
-     , vector, vector-builder, vinyl, yaml
+    ({ mkDerivation, aeson, approximate-equality, array, base
+     , bifunctors, bytestring, containers, contravariant, data-clist
+     , deepseq, directory, dlist, doctest, filepath, fingertree
+     , hashable, hspec, hspec-discover, lens, linear, math-functions
+     , MonadRandom, mtl, nonempty-vector, primitive, QuickCheck
+     , quickcheck-instances, random, reflection, semigroupoids
+     , semigroups, singletons, template-haskell, text
+     , unordered-containers, vector, vector-builder, vector-circular
+     , vinyl, yaml
      }:
      mkDerivation {
        pname = "hgeometry-combinatorial";
-       version = "0.11.0.0";
-       sha256 = "0qhb4aflqcjjm1qnhq7xsd086pk09gnq7q503ys4kzr8j0knc2j5";
+       version = "0.12.0.1";
+       sha256 = "0767c7ljw674zbj57nw3dsq2h56x6gw1r6ihyd2jg7djbf5k13ar";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         aeson base bifunctors bytestring containers contravariant
+         aeson array base bifunctors bytestring containers contravariant
          data-clist deepseq dlist fingertree hashable lens linear
-         MonadRandom mtl primitive QuickCheck quickcheck-instances random
-         reflection semigroupoids semigroups template-haskell text vector
-         vector-builder vinyl yaml
+         math-functions MonadRandom mtl nonempty-vector primitive QuickCheck
+         quickcheck-instances random reflection semigroupoids semigroups
+         template-haskell text unordered-containers vector vector-builder
+         vector-circular vinyl yaml
        ];
        testHaskellDepends = [
-         approximate-equality base bytestring containers data-clist
+         approximate-equality base bytestring containers data-clist deepseq
          directory doctest filepath hspec lens linear MonadRandom QuickCheck
          quickcheck-instances random semigroups singletons vector vinyl yaml
        ];
        testToolDepends = [ hspec-discover ];
        description = "Data structures, and Data types";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hgeometry-ipe" = callPackage
···
      }) {};
 
   "hkgr" = callPackage
-    ({ mkDerivation, base, directory, extra, filepath, simple-cabal
-     , simple-cmd, simple-cmd-args, xdg-basedir
+    ({ mkDerivation, base, bytestring, directory, extra, filepath
+     , simple-cabal, simple-cmd-args, typed-process, xdg-basedir
      }:
      mkDerivation {
        pname = "hkgr";
-       version = "0.2.6.1";
-       sha256 = "0hq059l3byw3vcxw56z341q56xnb86kdqj5vnn16v29ql677xm26";
+       version = "0.2.7";
+       sha256 = "1p03qigrfkjj0q8ps9gx50pnz6s2rdmn2lqnybhfz8pifsqj0z7k";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base directory extra filepath simple-cabal simple-cmd
-         simple-cmd-args xdg-basedir
+         base bytestring directory extra filepath simple-cabal
+         simple-cmd-args typed-process xdg-basedir
        ];
        description = "Simple Hackage release workflow for package maintainers";
        license = lib.licenses.gpl3;
···
        license = lib.licenses.asl20;
      }) {};
 
+  "hls-class-plugin_1_0_0_0" = callPackage
+    ({ mkDerivation, aeson, base, containers, ghc, ghc-exactprint
+     , ghcide, hls-plugin-api, lens, lsp, shake, text, transformers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "hls-class-plugin";
+       version = "1.0.0.0";
+       sha256 = "103rswyrbs35q6mmv19bnj4cp4r1n5mx6aazcabfakh1cix0fn60";
+       libraryHaskellDepends = [
+         aeson base containers ghc ghc-exactprint ghcide hls-plugin-api lens
+         lsp shake text transformers unordered-containers
+       ];
+       description = "Class/instance management plugin for Haskell Language Server";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hls-eval-plugin" = callPackage
     ({ mkDerivation, aeson, base, containers, deepseq, Diff, directory
      , dlist, extra, filepath, ghc, ghc-boot-th, ghc-paths, ghcide
···
        license = lib.licenses.asl20;
      }) {};
 
+  "hls-haddock-comments-plugin_1_0_0_0" = callPackage
+     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+     , hls-plugin-api, lsp-types, text, unordered-containers
+     }:
+     mkDerivation {
+     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+       version = "1.0.0.0";
+       sha256 = "1azy3rrbdi465c65f603ycj14mz1cvc9h92rrf0b0frs90hs66r3";
+       libraryHaskellDepends = [
+         base containers ghc ghc-exactprint ghcide hls-plugin-api lsp-types
+         text unordered-containers
+       ];
+     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
      , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
      , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
      , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
···
        license = lib.licenses.asl20;
      }) {};
 
-     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+  "hls-plugin-api_1_0_0_0" = callPackage
     ({ mkDerivation, aeson, base, containers, data-default
      , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
      , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
···
      }:
      mkDerivation {
      , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
-       version = "0.7.1.0";
-     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+       version = "1.0.0.0";
+       sha256 = "03pj0irgf9p84jn5kfd4cfyqk4xyfdf9pfrwqhb0c1ipnm4l7wal";
        libraryHaskellDepends = [
      , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
      , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
···
        testToolDepends = [ hspec-discover ];
      , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
        license = lib.licenses.asl20;
+     }) {};
+
+  "hls-tactics-plugin_1_0_0_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, checkers, containers
+     , data-default, deepseq, directory, extra, filepath, fingertree
+     , generic-lens, ghc, ghc-boot-th, ghc-exactprint, ghc-source-gen
+     , ghcide, hie-bios, hls-plugin-api, hspec, hspec-discover
+     , hspec-expectations, lens, lsp, lsp-test, lsp-types, megaparsec
+     , mtl, QuickCheck, refinery, retrie, shake, syb, tasty
+     , tasty-ant-xml, tasty-expected-failure, tasty-golden, tasty-hunit
+     , tasty-rerun, text, transformers
+     }:
+     mkDerivation {
+     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+       version = "1.0.0.0";
+       sha256 = "0cd6d3m3w1n7x22k5xndjl9r440s5nx6q2fg3wcmdsbd3s3pg1qa";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+         hls-plugin-api lens lsp mtl refinery retrie shake syb text
+         transformers
+       ];
+       executableHaskellDepends = [
+         base data-default ghcide hls-plugin-api shake
+       ];
+       testHaskellDepends = [
+         aeson base bytestring checkers containers data-default deepseq
+         directory filepath ghc ghcide hie-bios hls-plugin-api hspec
+         hspec-expectations lens lsp-test lsp-types megaparsec mtl
+         QuickCheck tasty tasty-ant-xml tasty-expected-failure tasty-golden
+         tasty-hunit tasty-rerun text
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Wingman plugin for Haskell Language Server";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
      , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
···
        license = lib.licenses.mit;
      }) {};
 
+  "hslua-core" = callPackage
+    ({ mkDerivation, base, bytestring, exceptions, lua, lua-arbitrary
+     , mtl, QuickCheck, quickcheck-instances, tasty, tasty-hunit
+     , tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "hslua-core";
+       version = "1.0.0";
+       sha256 = "1dkm0w0cpdkakx2ka8csjpg2dlzv49xxij884g1kzwg2k85l4xyy";
+       libraryHaskellDepends = [
+         base bytestring exceptions lua mtl text
+       ];
+       testHaskellDepends = [
+         base bytestring exceptions lua lua-arbitrary mtl QuickCheck
+         quickcheck-instances tasty tasty-hunit tasty-quickcheck text
+       ];
+       description = "Bindings to Lua, an embeddable scripting language";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {lua-arbitrary = null;};
+
   "hslua-module-doclayout" = callPackage
     ({ mkDerivation, base, doclayout, hslua, tasty, tasty-hunit
      , tasty-lua, text
···
      }:
      mkDerivation {
        pname = "http-query";
-       version = "0.1.0";
-       sha256 = "1j2ad7ym5mkpavlw1fp07n4qlggms04i93l5rv6vg07ljf4imjvs";
+       version = "0.1.0.1";
+       sha256 = "11l3bxbaxkd0mrarp5l3s3c4xhvdiq8lj739hxspi6cgk0ywjwxw";
        libraryHaskellDepends = [
          aeson base bytestring http-conduit network-uri text
        ];
···
        pname = "hum";
        version = "0.2.0.0";
        sha256 = "144b1161rvlmayklvgm7cajs0jz5bhlbcgrq288pvymlyl4f962b";
-       revision = "2";
-       editedCabalFile = "03hh7nyqchskkp4iqcq335mnpdsvgdw8d1pf3dp7p4wmsk20kwmk";
+       revision = "3";
+       editedCabalFile = "1wj4rf5gn2zqlym2hrl5iiakyvh1h8n2z788wzzjvfx4xwsb5gp3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testSystemDepends = [ zookeeper_mt ];
        description = "Haskell client library for Apache Zookeeper";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) zookeeper_mt;};
 
   "hzulip" = callPackage
···
      }:
      mkDerivation {
        pname = "ice40-prim";
-       version = "0.1.0.0";
-       sha256 = "00l0kwwayf0bark2yqjrx8imr8997d5mrnhjf3zsayxk9a521j99";
+       version = "0.2.0.0";
+       sha256 = "02dm3zqq24phhxis471gp91figkazpwpz0ndhazp14jajxvka0cd";
        libraryHaskellDepends = [
          base Cabal clash-prelude ghc-typelits-extra ghc-typelits-knownnat
          ghc-typelits-natnormalise interpolate
···
      }:
      mkDerivation {
        pname = "inventory";
-       version = "0.1.0.0";
-       sha256 = "0nflfrs9qb2bfkpi07r2a5k6lkyyspvfqz18pfvqa2rkpfcqw9bd";
+       version = "0.1.0.2";
+       sha256 = "1ykfxlsgnim45b4birflpwj0p3grjw8y4p9vwqnmhss6krl2qk3x";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "Automatically generate a function's inverse";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "invertible" = callPackage
···
      }:
      mkDerivation {
        pname = "ipfs";
-       version = "1.1.5.1";
-       sha256 = "0c93s1s3l72yw2lb28v37bnhmvcn5s2w1620fsx0z4ij1z8dnk19";
+       version = "1.2.0.0";
+       sha256 = "12aibxpdkgwym8k8hibb8a77bbf7wd6z5czwpakg48x9gxmvhygn";
        libraryHaskellDepends = [
          aeson base bytestring envy flow Glob http-media ip lens
          monad-logger regex-compat rio servant servant-client servant-server
···
        testToolDepends = [ tasty-discover ];
        description = "JSON Pointer (RFC 6901) parsing, access, and modification";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "json-python" = callPackage
···
          recursion-schemes text unordered-containers vector
        ];
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "json-togo" = callPackage
···
      }:
      mkDerivation {
        pname = "kempe";
-       version = "0.1.1.2";
-       sha256 = "1nmmka06zin3i4y30510c56yk3vjxvnndfb38w4v557xr94rirkd";
+       version = "0.1.1.3";
+       sha256 = "0p0zm3dxjcmckwif966cnsn8qb667mxd8yh7wx56nl7jsxz90cw1";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        doHaddock = false;
        description = "Extracts values from /proc/cmdline";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "kqueue" = callPackage
···
      }:
      mkDerivation {
        pname = "launchdarkly-server-sdk";
-       version = "2.1.0";
-       sha256 = "1nj6jcmara4x8y292q5qacli6hmfhahw856a0nyngca2c8m5mwr1";
+       version = "2.1.1";
+       sha256 = "1gjiwj8x57z9qs9gxdgqyih38i8rkkvjak4va5cg44qp3rflmby1";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring
          bytestring-conversion clock containers cryptohash exceptions extra
···
     ({ mkDerivation, base, bytestring, text }:
      mkDerivation {
        pname = "leanpub-concepts";
-       version = "1.0.0.1";
-       sha256 = "1vf62iryqmj8ll16cm5xpwaqzlhw8rb7p6pshm87assm9lnw3k8c";
+       version = "1.1";
+       sha256 = "0zy26sccxyqhmlk6dfbd7jghwmfi9zkcljb9rcl82ysw7cwyl3qw";
        libraryHaskellDepends = [ base bytestring text ];
        description = "Types for the Leanpub API";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "leanpub-wreq";
-       version = "1.0.0.0";
-       sha256 = "060ilipz2aj7rci6yiy2r6j8c10hlv8q8qv5wm7ic9rjl2gvx4ra";
+       version = "1.1";
+       sha256 = "1mk188r1bxg3qhv24nxkqw5vk5jyifxvg171h8bx93s9mmrikzdv";
        libraryHaskellDepends = [
          aeson base bytestring exceptions leanpub-concepts lens rando text
          time transformers unordered-containers wreq
···
     ({ mkDerivation, base, hspec, template-haskell, transformers }:
      mkDerivation {
        pname = "lens-family-th";
-       version = "0.5.1.0";
-       sha256 = "1gpjfig8a2dh4v4660rg659hpvrf2vv85v7cwn64xg3043i954qi";
+       version = "0.5.2.0";
+       sha256 = "00glipk0mzq6mjvdi2lqys1d9gsncvphcccigw2ry8k9zc8l85zb";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base hspec template-haskell transformers ];
        description = "Generate lens-family style lenses";
···
        pname = "lens-process";
        version = "0.4.0.0";
        sha256 = "1gms2bxa1sygpid09cg3nk1kyhkg4s38dqs0gd77ia2aln6zd7qg";
+       revision = "1";
+       editedCabalFile = "0y1ran4pjqr2226rkmiqij0pf980npr7iv88y5bgcg7hs22f3b57";
        libraryHaskellDepends = [ base filepath lens process ];
        testHaskellDepends = [
          base filepath lens process tasty tasty-hunit
        ];
        description = "Optics for system processes";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "lens-properties" = callPackage
···
      }:
      mkDerivation {
        pname = "lentil";
-       version = "1.5.0.0";
-       sha256 = "1fkgaf4vgn2b8pkvcc9x3dmigqrq4qp31xvjmp3h0g9s1bm9ay5z";
+       version = "1.5.1.0";
+       sha256 = "03h7fk37rrxpnxfpckpfi5k3v7ch4v5vn601m9lj9shbs26h1cdx";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }) {};
 
   "lifted-async" = callPackage
-    ({ mkDerivation, async, base, constraints, criterion, deepseq
-     , HUnit, lifted-base, monad-control, mtl, tasty
-     , tasty-expected-failure, tasty-hunit, tasty-th, transformers-base
-     }:
-     mkDerivation {
-       pname = "lifted-async";
-       version = "0.10.1.2";
-       sha256 = "04spjv6l7bpdl3wla78yqg8misq5ym6vi4q8d03iaw2kg4cwn95x";
-       libraryHaskellDepends = [
-         async base constraints lifted-base monad-control transformers-base
-       ];
-       testHaskellDepends = [
-         async base HUnit lifted-base monad-control mtl tasty
-         tasty-expected-failure tasty-hunit tasty-th
-       ];
-       benchmarkHaskellDepends = [ async base criterion deepseq ];
-       description = "Run lifted IO operations asynchronously and wait for their results";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "lifted-async_0_10_1_3" = callPackage
     ({ mkDerivation, async, base, constraints, deepseq, HUnit
      , lifted-base, monad-control, mtl, tasty, tasty-bench
      , tasty-expected-failure, tasty-hunit, tasty-th, transformers-base
···
        benchmarkHaskellDepends = [ async base deepseq tasty-bench ];
        description = "Run lifted IO operations asynchronously and wait for their results";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lifted-base" = callPackage
···
        ];
        description = "Standard library for linear types";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "linear-circuit" = callPackage
···
        broken = true;
      }) {};
 
+  "lion" = callPackage
+    ({ mkDerivation, base, Cabal, clash-prelude, generic-monoid
+     , ghc-typelits-extra, ghc-typelits-knownnat
+     , ghc-typelits-natnormalise, ice40-prim, lens, mtl
+     }:
+     mkDerivation {
+       pname = "lion";
+       version = "0.1.0.0";
+       sha256 = "0sxj7rjx9xzrmzy0q415b7vhxvj5fp38av1qs3sx54frmzbm0x20";
+       libraryHaskellDepends = [
+         base Cabal clash-prelude generic-monoid ghc-typelits-extra
+         ghc-typelits-knownnat ghc-typelits-natnormalise ice40-prim lens mtl
+       ];
+       description = "RISC-V Core";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "lipsum-gen" = callPackage
     ({ mkDerivation, base, QuickCheck }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "log-base";
-       version = "0.9.0.0";
-       sha256 = "0rlwr80636b4rrjgqg7ri5cfz95v9h47r9k413r9wvldfvz2abyg";
+       version = "0.9.1.0";
+       sha256 = "0p0zb805a8zlxdnii6r0gmf0zic4g4zxkvcq84j6g8973qx1fch9";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring deepseq exceptions mmorph
          monad-control monad-time mtl semigroups stm text time
···
        testHaskellDepends = [ base directory filepath simple-cmd ];
        description = "List dir files starting from a specific name";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "lsp" = callPackage
···
        pname = "lsp-types";
        version = "1.1.0.0";
        sha256 = "19lkdqwh9a5rsx5nby37v54zhwyja306z0dyslsmdmwqw92qxx54";
+       revision = "1";
+       editedCabalFile = "0iifws4r1h9v1mbsrmbvssvm0gmvzm9yh9h85izly0s51869bbq4";
        libraryHaskellDepends = [
          aeson base binary bytestring containers data-default deepseq
          dependent-sum dependent-sum-template directory filepath hashable
···
      }:
      mkDerivation {
        pname = "lti13";
-       version = "0.2.0.0";
-       sha256 = "004zic7k2a4cii4ny3vbnwn7vwrzbfvi971xz8wgsnvnjmjnpfsq";
+       version = "0.2.0.1";
+       sha256 = "1fcjypadap94f238vnhbchq9dy61mhgwlqpy4v22m34881dvx8gf";
        libraryHaskellDepends = [
          aeson base bytestring containers http-client http-types jose-jwt
          oidc-client safe-exceptions text
···
      }:
      mkDerivation {
        pname = "lucid";
-       version = "2.9.12";
-       sha256 = "156wniydd1hlb7rygbm95zln8ky8lai8rn2apkkv0rax9cdw6jrh";
-       revision = "1";
-       editedCabalFile = "1f0whk5ncanxfjjanrf6rqyncig2xgc5mh2j0sqy3nrlyjr9aqq9";
+       version = "2.9.12.1";
+       sha256 = "0nky4pqxd6828kg3js90ks6r3hxs5x48ibfz37pw2dr7y1nygq21";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers hashable mmorph mtl text
          transformers unordered-containers
···
     ({ mkDerivation, base, containers, hspec, QuickCheck }:
      mkDerivation {
        pname = "matroid";
-       version = "0.0.0";
-       sha256 = "0k7x9m8zn45s9r9frpqagrjkwbmfd9hfx2v1kwx7h5gfdkmkpb5z";
+       version = "0.0.0.1.1";
+       sha256 = "1lkahlkfm6vrss0wpfg943q0m9dqqkl7cy3f37p4h185375qyj42";
        libraryHaskellDepends = [ base containers hspec QuickCheck ];
        testHaskellDepends = [ base containers hspec QuickCheck ];
        description = "matroid (combinatorial pre-geometries) library";
···
        doHaddock = false;
        description = "A minimal base to work around GHC bugs";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "microbench" = callPackage
···
        benchmarkHaskellDepends = [ base criterion text weigh ];
        description = "Strict markdown processor for writers";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "mmark-cli" = callPackage
···
        ];
        description = "Command line interface to the MMark markdown processor";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "mmark-ext" = callPackage
···
        testToolDepends = [ hspec-discover ];
        description = "Commonly useful extensions for the MMark markdown processor";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "mmorph_1_1_3" = callPackage
···
        pname = "mmorph";
        version = "1.1.5";
        sha256 = "0bq9m3hlfax1826gg5yhih79x33rvfx59wdh8yf43azd7l74bys6";
+       revision = "1";
+       editedCabalFile = "087v8ajcfpx4f0v4jxvv16h6jswgnkfnyfn28k406d5w3ihcx1wl";
        libraryHaskellDepends = [
          base mtl transformers transformers-compat
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "modern-uri_0_3_4_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, contravariant
+     , criterion, deepseq, exceptions, hspec, hspec-discover
+     , hspec-megaparsec, megaparsec, mtl, profunctors, QuickCheck
+     , reflection, tagged, template-haskell, text, weigh
+     }:
+     mkDerivation {
+       pname = "modern-uri";
+       version = "0.3.4.1";
+       sha256 = "09yzn5lim3wv0120lfdwlc8ynx15z3p6p0js2r6ij3rzx26nchqd";
+       libraryHaskellDepends = [
+         base bytestring containers contravariant deepseq exceptions
+         megaparsec mtl profunctors QuickCheck reflection tagged
+         template-haskell text
+       ];
+       testHaskellDepends = [
+         base bytestring hspec hspec-megaparsec megaparsec QuickCheck text
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion deepseq megaparsec text weigh
+       ];
+       description = "Modern library for working with URIs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "modify-fasta" = callPackage
     ({ mkDerivation, base, containers, fasta, mtl, optparse-applicative
      , pipes, pipes-text, regex-tdfa, regex-tdfa-text, semigroups, split
···
      }:
      mkDerivation {
        pname = "monad-coroutine";
-       version = "0.9.0.4";
-       sha256 = "1rsxzry8qk5229vx4iw4jrzbbc82m80m1nlxlq73k5k20h9gzq0k";
+       version = "0.9.1";
+       sha256 = "1d85jyfwf4h60cfp3dyrkmf7kw7ya37z2vqmv6rdbpqc1pslmb1i";
        libraryHaskellDepends = [
          base monad-parallel transformers transformers-compat
        ];
···
      }:
      mkDerivation {
        pname = "monad-parallel";
-       version = "0.7.2.3";
-       sha256 = "12ahni860pfkdj70f9d0dg2h93gl0d9qav8llcmgh5z7dg1vi3qj";
+       version = "0.7.2.4";
+       sha256 = "1h36hwbk800v0cq2x8kxf7v3gkr8maws7ijxckvsqp480xr4r5xx";
        libraryHaskellDepends = [
          base parallel transformers transformers-compat
        ];
···
        pname = "monoid-extras";
        version = "0.5.1";
        sha256 = "0xfrkgqn9d31z54l617m3w3kkd5m9vjb4yl247r3zzql3mpb1f37";
-       revision = "1";
-       editedCabalFile = "0b8x5d6vh7mpigvjvcd8f38a1nyzn1vfdqypslw7z9fgsr742913";
+       revision = "2";
+       editedCabalFile = "0gbrwpr7rzh9mmf59yhs74hixgclmxngaxx51j7pvr6wnkbvz3a3";
        libraryHaskellDepends = [ base groups semigroupoids semigroups ];
        benchmarkHaskellDepends = [ base criterion semigroups ];
        description = "Various extra monoid-related definitions and utilities";
···
        ];
        description = "Morpheus GraphQL Core";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "morpheus-graphql-cli" = callPackage
···
      }:
      mkDerivation {
        pname = "musicw";
-       version = "0.3.6";
-       sha256 = "0bi57x087r22547z90n58faz78ha6z6pfmf2chwrfdys48lr8wfq";
+       version = "0.3.7";
+       sha256 = "0b5wn084ka4xnvimzxd47y4m0ldmfqr7sa30a5bm08g62333h3yr";
        libraryHaskellDepends = [
          array base bytestring containers data-default file-embed ghcjs-base
          ghcjs-dom ghcjs-prim json monad-loops mtl safe text time
···
        ];
        description = "A representation of the MusicXML format";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "mustache" = callPackage
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) mysql;};
 
+  "mysql_0_2" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, hspec, mysql
+     }:
+     mkDerivation {
+       pname = "mysql";
+       version = "0.2";
+       sha256 = "09b1rhv16g8npjblq9jfi29bffsplvq4hnksdhknd39anr5gpqzc";
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [ base bytestring containers ];
+       librarySystemDepends = [ mysql ];
+       testHaskellDepends = [ base bytestring hspec ];
+       description = "A low-level MySQL client library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) mysql;};
+
   "mysql-effect" = callPackage
     ({ mkDerivation, base, bytestring, extensible-effects, mysql
      , mysql-simple
···
      }:
      mkDerivation {
        pname = "netpbm";
-       version = "1.0.3";
-       sha256 = "17cxh15wf7m9ljg0scd5i71ki95fiz8qhrfk4w1zvk4pf2gb7z38";
+       version = "1.0.4";
+       sha256 = "0728k34q14f3rv6rfln7lh8clb1r7nigxri6fkl4q7dbf6i8n86p";
        libraryHaskellDepends = [
          attoparsec attoparsec-binary base bytestring storable-record
          unordered-containers vector vector-th-unbox
···
      }:
      mkDerivation {
        pname = "ngx-export";
-       version = "1.7.1";
-       sha256 = "0dylj1i6370r1yz2rgjpjs5ynsvaqshgvz71200r0q2hqqznax6d";
+       version = "1.7.3";
+       sha256 = "18pdvmyhqil98d5mzh8a4r5i3pc4vyj13jcrjjw4q73prcj4mg6p";
        libraryHaskellDepends = [
          async base binary bytestring deepseq monad-loops template-haskell
          unix
···
      }) {};
 
   "nix-diff" = callPackage
-    ({ mkDerivation, attoparsec, base, containers, Diff, directory, mtl
-     , nix-derivation, optparse-applicative, text, unix, vector
+    ({ mkDerivation, attoparsec, base, containers, directory, mtl
+     , nix-derivation, optparse-applicative, patience, text, unix
+     , vector
      }:
      mkDerivation {
        pname = "nix-diff";
-       version = "1.0.11";
-       sha256 = "0pi0nqhv48f90ls40whifw1lcld5sw3hcrz7kzy14s4sc6ln9543";
+       version = "1.0.12";
+       sha256 = "1w994nxgmg9cyrvqz13d5qjp3dqprdh16w2adcc5mbs3nqm9nmrc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         attoparsec base containers Diff directory mtl nix-derivation
-         optparse-applicative text unix vector
+         attoparsec base containers directory mtl nix-derivation
+         optparse-applicative patience text unix vector
        ];
        description = "Explain why two Nix derivations differ";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "nix-tree" = callPackage
-    ({ mkDerivation, aeson, base, brick, bytestring, containers
+    ({ mkDerivation, aeson, base, brick, bytestring, clock, containers
      , deepseq, directory, filepath, hashable, hedgehog, hrfsize
      , protolude, text, transformers, typed-process
      , unordered-containers, vty
      }:
      mkDerivation {
        pname = "nix-tree";
-       version = "0.1.4";
-       sha256 = "1hbb4p6yz8c7c49yxqvzmiq9knpsm958pk9vbj12jii3ihdf0pl6";
+       version = "0.1.5";
+       sha256 = "1iymfgffafqh57m0b8mrsrcd8m6x3wycwm2lly0bz1q4z784k66v";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         aeson base brick bytestring containers deepseq directory filepath
-         hashable hrfsize protolude text transformers typed-process
+         aeson base brick bytestring clock containers deepseq directory
+         filepath hashable hrfsize protolude text transformers typed-process
          unordered-containers vty
        ];
        testHaskellDepends = [
-         aeson base brick bytestring containers deepseq directory filepath
-         hashable hedgehog hrfsize protolude text transformers typed-process
-         unordered-containers vty
+         aeson base brick bytestring clock containers deepseq directory
+         filepath hashable hedgehog hrfsize protolude text transformers
+         typed-process unordered-containers vty
        ];
        description = "Interactively browse a Nix store paths dependencies";
        license = lib.licenses.bsd3;
···
        pname = "nothunks";
        version = "0.1.2";
        sha256 = "0z9calmdw4bk4cdwrfq5nkxxks2f82q59i7kv6lnsgwyl4nqvg2y";
+       revision = "1";
+       editedCabalFile = "18q60yrm0fwb7zs4saxv4f3gk2av4dmbjag04kxzrllfy34h3y6z";
        libraryHaskellDepends = [
          base bytestring containers ghc-heap stm text time vector
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "nri-env-parser_0_1_0_5" = callPackage
+    ({ mkDerivation, base, modern-uri, network-uri, nri-prelude, text
+     }:
+     mkDerivation {
+       pname = "nri-env-parser";
+       version = "0.1.0.5";
+       sha256 = "18xxgr82fqnl1s24gcwn7sdq50nsjk4zjl52h14f8zgw4cvkql1h";
+       libraryHaskellDepends = [
+         base modern-uri network-uri nri-prelude text
+       ];
+       description = "Read environment variables as settings to build 12-factor apps";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "nri-observability" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, async, base, bugsnag-hs
+     , bytestring, directory, hostname, http-client, http-client-tls
+     , nri-env-parser, nri-prelude, random, safe-exceptions, stm, text
+     , time, unordered-containers
+     }:
+     mkDerivation {
+       pname = "nri-observability";
+       version = "0.1.0.0";
+       sha256 = "121ajy98n0qwn38ia4x1gcy0nz2zygjwyi1lxywwijqdzcnl1yal";
+       libraryHaskellDepends = [
+         aeson aeson-pretty async base bugsnag-hs bytestring directory
+         hostname http-client http-client-tls nri-env-parser nri-prelude
+         random safe-exceptions stm text time unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty async base bugsnag-hs bytestring directory
+         hostname http-client http-client-tls nri-env-parser nri-prelude
+         random safe-exceptions stm text time unordered-containers
+       ];
+       description = "Report log spans collected by nri-prelude";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "nri-prelude" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async
      , auto-update, base, bytestring, containers, directory, exceptions
···
        ];
        description = "A Prelude inspired by the Elm programming language";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "nri-prelude_0_5_0_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async
+     , auto-update, base, bytestring, containers, directory, exceptions
+     , filepath, ghc, hedgehog, junit-xml, pretty-diff, pretty-show
+     , safe-exceptions, terminal-size, text, time, vector
+     }:
+     mkDerivation {
+       pname = "nri-prelude";
+       version = "0.5.0.0";
+       sha256 = "1avpj21scw9c45208wf8q86n0fs73k3lgm54mgqdwln1m1ajfnvg";
+       libraryHaskellDepends = [
+         aeson aeson-pretty ansi-terminal async auto-update base bytestring
+         containers directory exceptions filepath ghc hedgehog junit-xml
+         pretty-diff pretty-show safe-exceptions terminal-size text time
+         vector
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty ansi-terminal async auto-update base bytestring
+         containers directory exceptions filepath ghc hedgehog junit-xml
+         pretty-diff pretty-show safe-exceptions terminal-size text time
+         vector
+       ];
+       description = "A Prelude inspired by the Elm programming language";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "nsis" = callPackage
···
        broken = true;
      }) {};
 
+  "openapi3_3_0_2_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries
+     , bytestring, Cabal, cabal-doctest, containers, cookie, doctest
+     , generics-sop, Glob, hashable, hspec, hspec-discover, http-media
+     , HUnit, insert-ordered-containers, lens, mtl, network, optics-core
+     , optics-th, QuickCheck, quickcheck-instances, scientific
+     , template-haskell, text, time, transformers, unordered-containers
+     , utf8-string, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "openapi3";
+       version = "3.0.2.0";
+       sha256 = "00qpbj2lvaysbwgbax7z1vyixzd0x7yzbz26aw5zxd4asddypbfg";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         aeson aeson-pretty base base-compat-batteries bytestring containers
+         cookie generics-sop hashable http-media insert-ordered-containers
+         lens mtl network optics-core optics-th QuickCheck scientific
+         template-haskell text time transformers unordered-containers
+         uuid-types vector
+       ];
+       executableHaskellDepends = [ aeson base lens text ];
+       testHaskellDepends = [
+         aeson base base-compat-batteries bytestring containers doctest Glob
+         hashable hspec HUnit insert-ordered-containers lens mtl QuickCheck
+         quickcheck-instances template-haskell text time
+         unordered-containers utf8-string vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "OpenAPI 3.0 data model";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "openapi3-code-generator" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, directory
      , filepath, genvalidity, genvalidity-hspec, genvalidity-text
···
        license = lib.licenses.asl20;
      }) {};
 
+  "ory-hydra-client" = 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 = "ory-hydra-client";
+       version = "1.9.2";
+       sha256 = "0z1897xl10465mzhriis9bmxk0hnswl5ap2m6x8ks5m120irh894";
+       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 ory-hydra API Client";
+       license = lib.licenses.mit;
+     }) {};
+
   "os-release" = callPackage
     ({ mkDerivation, aeson, base, bytestring, filepath, hspec
      , hspec-megaparsec, megaparsec, pretty-simple, safe-exceptions
···
      }:
      mkDerivation {
        pname = "os-release";
-       version = "1.0.1";
-       sha256 = "05ajgnihm82ikxgvfnam0msn7id2apiyin9757jrc8wfsh3xvkmx";
+       version = "1.0.2";
+       sha256 = "0wjf1z76pqfv091b88zc3w0hmqv8i2i6qsx21cfcgaym4r3zqpjf";
        libraryHaskellDepends = [
          aeson base megaparsec safe-exceptions text unordered-containers
        ];
···
        license = lib.licenses.gpl2Plus;
      }) {};
 
+  "pandoc-plot_1_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, criterion
+     , data-default, directory, filepath, githash, hashable, hspec
+     , hspec-expectations, lifted-async, lifted-base, mtl
+     , optparse-applicative, pandoc, pandoc-types, shakespeare, tagsoup
+     , tasty, tasty-hspec, tasty-hunit, template-haskell, text
+     , typed-process, yaml
+     }:
+     mkDerivation {
+       pname = "pandoc-plot";
+       version = "1.1.0";
+       sha256 = "1dk9s37z3hah1kiha3q9d1yzl0vfgivdazhdcraivaspzi78iry8";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers data-default directory filepath hashable
+         lifted-async lifted-base mtl pandoc pandoc-types shakespeare
+         tagsoup template-haskell text typed-process yaml
+       ];
+       executableHaskellDepends = [
+         base containers directory filepath githash optparse-applicative
+         pandoc pandoc-types template-haskell text typed-process
+       ];
+       testHaskellDepends = [
+         base containers directory filepath hspec hspec-expectations
+         pandoc-types tasty tasty-hspec tasty-hunit text
+       ];
+       benchmarkHaskellDepends = [
+         base criterion pandoc-types template-haskell text
+       ];
+       description = "A Pandoc filter to include figures generated from code blocks using your plotting toolkit of choice";
+       license = lib.licenses.gpl2Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "pandoc-pyplot" = callPackage
     ({ mkDerivation, base, containers, data-default-class, deepseq
      , directory, filepath, hashable, hspec, hspec-expectations, mtl
···
        ];
        description = "A generalization of the uniqueness-periods-vector-examples functionality";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "phonetic-languages-filters-array" = callPackage
···
        ];
        description = "A generalization of the uniqueness-periods-vector-properties package";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "phonetic-languages-rhythmicity" = callPackage
···
        ];
        description = "Simplified and somewhat optimized version of the phonetic-languages-examples";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "phonetic-languages-simplified-properties-array" = callPackage
···
        ];
        description = "A generalization of the uniqueness-periods-vector-properties package";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "phonetic-languages-simplified-properties-lists-double" = callPackage
···
        ];
        description = "A generalization of the uniqueness-periods-vector-properties package";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "phonetic-languages-ukrainian" = callPackage
···
      }:
      mkDerivation {
        pname = "pinboard-notes-backup";
-       version = "1.0.5";
-       sha256 = "042zph3nisrmhkfk2h3fwh91dz1fp0wgff0hlnpd962i67fgpixx";
+       version = "1.0.5.2";
+       sha256 = "0lhccldfya4pj5446kh23ahyb7vrd33jxrf1xgk4i3xiwv9bvpyy";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "Back up the notes you've saved to Pinboard";
        license = lib.licenses.gpl3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "pinch" = callPackage
···
     ({ mkDerivation, base, foldl, hspec, pipes, pipes-safe }:
      mkDerivation {
        pname = "pipes-ordered-zip";
-       version = "1.1.0";
-       sha256 = "1fs0qyhc4a7xnglxl7b1d615s9ajml6pvch337ivny31cxrngcsa";
-       libraryHaskellDepends = [ base pipes pipes-safe ];
-       testHaskellDepends = [ base foldl hspec pipes pipes-safe ];
-       description = "merge two ordered Producers into a new Producer";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "pipes-ordered-zip_1_2_1" = callPackage
-    ({ mkDerivation, base, foldl, hspec, pipes, pipes-safe }:
-     mkDerivation {
-       pname = "pipes-ordered-zip";
        version = "1.2.1";
        sha256 = "0jgqnx5jdra5v0r7v564zzd96jfv42lbkdxgk1k7ip8gcikb1zdm";
        libraryHaskellDepends = [ base pipes pipes-safe ];
        testHaskellDepends = [ base foldl hspec pipes pipes-safe ];
        description = "merge two ordered Producers into a new Producer";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pipes-p2p" = callPackage
···
        testHaskellDepends = [ base ];
        description = "A program for turning pixel art into 3D prints";
        license = lib.licenses.gpl3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "pixela" = callPackage
···
        pname = "postgrest";
        version = "7.0.1";
        sha256 = "1cn69dinfv3y8ymsa364b9b0ly3dg80and902gamymb9v89jpsgf";
-       revision = "5";
-       editedCabalFile = "0cfw145pna4k1jjcmkffwaw2h8ls9crngmzcsi2jhc85s90gq2fv";
+       revision = "6";
+       editedCabalFile = "0kkhkz1bmgc1p0yry24fhc4a3s9w28wg6gxai0cggvalbz8c4pc4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "pretty-diff";
-       version = "0.4.0.2";
-       sha256 = "0wa70is5pmad4f0spj5hmi56y290k1xizs4zwlrgry65r8c1qgns";
-       libraryHaskellDepends = [ base data-default Diff text ];
-       testHaskellDepends = [
-         base data-default Diff tasty tasty-hunit tasty-test-reporter text
-       ];
-       description = "Pretty printing a diff of two values";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "pretty-diff_0_4_0_3" = callPackage
-    ({ mkDerivation, base, data-default, Diff, tasty, tasty-hunit
-     , tasty-test-reporter, text
-     }:
-     mkDerivation {
-       pname = "pretty-diff";
        version = "0.4.0.3";
        sha256 = "0qzsq9dm95f6yjryl2675rbyx178zxl562x0y9i1py2rx4k8z7gl";
        libraryHaskellDepends = [ base data-default Diff text ];
···
        ];
        description = "Pretty printing a diff of two values";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pretty-display" = callPackage
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "process-sequential" = callPackage
+    ({ mkDerivation, base, directory, mmsyn3, process, sublists }:
+     mkDerivation {
+       pname = "process-sequential";
+       version = "0.1.0.0";
+       sha256 = "11s6ki1cgqav8i06np63cj2l6z1wdszjrq2rslx1pk7af5dxz9r0";
+       libraryHaskellDepends = [ base directory mmsyn3 process sublists ];
+       description = "A test suite for the complex multi files multi level processment";
+       license = lib.licenses.mit;
      }) {};
 
   "process-streaming" = callPackage
···
      , ansi-terminal, ansi-wl-pprint, array, base, base-compat
      , blaze-html, bower-json, boxes, bytestring, Cabal, cborg
      , cheapskate, clock, containers, cryptonite, data-ordlist, deepseq
-     , directory, dlist, edit-distance, file-embed, filepath, fsnotify
-     , gitrev, Glob, happy, haskeline, hspec, hspec-discover, http-types
-     , HUnit, language-javascript, lifted-async, lifted-base, memory
+     , directory, edit-distance, file-embed, filepath, fsnotify, gitrev
+     , Glob, happy, haskeline, hspec, hspec-discover, http-types, HUnit
+     , language-javascript, lifted-async, lifted-base, memory
      , microlens-platform, monad-control, monad-logger, mtl, network
      , optparse-applicative, parallel, parsec, pattern-arrows, process
-     , protolude, regex-tdfa, safe, scientific, semialign, semigroups
-     , serialise, sourcemap, split, stm, stringsearch, syb, tasty
-     , tasty-golden, tasty-hspec, tasty-quickcheck, text, these, time
-     , transformers, transformers-base, transformers-compat
-     , unordered-containers, utf8-string, vector, wai, wai-websockets
-     , warp, websockets
+     , protolude, purescript-ast, purescript-cst, regex-base, regex-tdfa
+     , safe, semialign, semigroups, serialise, sourcemap, split, stm
+     , stringsearch, syb, tasty, tasty-golden, tasty-hspec
+     , tasty-quickcheck, text, these, time, transformers
+     , transformers-base, transformers-compat, unordered-containers
+     , utf8-string, vector, wai, wai-websockets, warp, websockets
      }:
      mkDerivation {
        pname = "purescript";
-       version = "0.13.8";
-       sha256 = "0sh9z3ir3jiwmi5h95v9p7j746xxidg1hrxha89c0zl6vr4sq7vh";
-       revision = "1";
-       editedCabalFile = "1ilnqfxscwkr0jl09y1dwi2aabwnghd0l22lm32jgfyq04njpc2a";
+     , kcd-parser, lens, resourcet, tasty, tasty-hunit, text
+       sha256 = "1bv68y91l6fyjidfp71djiv2lijn5d55j4szlg77yvsw164s6vk0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-better-errors aeson-pretty ansi-terminal array base
          base-compat blaze-html bower-json boxes bytestring Cabal cborg
          cheapskate clock containers cryptonite data-ordlist deepseq
-         directory dlist edit-distance file-embed filepath fsnotify Glob
-         haskeline language-javascript lifted-async lifted-base memory
+         directory edit-distance file-embed filepath fsnotify Glob haskeline
+         language-javascript lifted-async lifted-base memory
          microlens-platform monad-control monad-logger mtl parallel parsec
-         pattern-arrows process protolude regex-tdfa safe scientific
-         semialign semigroups serialise sourcemap split stm stringsearch syb
-         text these time transformers transformers-base transformers-compat
-         unordered-containers utf8-string vector
+         pattern-arrows process protolude purescript-ast purescript-cst
+         regex-tdfa safe semialign semigroups serialise sourcemap split stm
+         stringsearch syb text these time transformers transformers-base
+         transformers-compat unordered-containers utf8-string vector
        ];
        libraryToolDepends = [ happy ];
        executableHaskellDepends = [
          aeson aeson-better-errors aeson-pretty ansi-terminal ansi-wl-pprint
          array base base-compat blaze-html bower-json boxes bytestring Cabal
          cborg cheapskate clock containers cryptonite data-ordlist deepseq
-         directory dlist edit-distance file-embed filepath fsnotify gitrev
-         Glob haskeline http-types language-javascript lifted-async
-         lifted-base memory microlens-platform monad-control monad-logger
-         mtl network optparse-applicative parallel parsec pattern-arrows
-         process protolude regex-tdfa safe scientific semialign semigroups
-         serialise sourcemap split stm stringsearch syb text these time
-         transformers transformers-base transformers-compat
+         directory edit-distance file-embed filepath fsnotify gitrev Glob
+         haskeline http-types language-javascript lifted-async lifted-base
+         memory microlens-platform monad-control monad-logger mtl network
+         optparse-applicative parallel parsec pattern-arrows process
+         protolude purescript-ast purescript-cst regex-tdfa safe semialign
+         semigroups serialise sourcemap split stm stringsearch syb text
+         these time transformers transformers-base transformers-compat
          unordered-containers utf8-string vector wai wai-websockets warp
          websockets
        ];
···
          aeson aeson-better-errors aeson-pretty ansi-terminal array base
          base-compat blaze-html bower-json boxes bytestring Cabal cborg
          cheapskate clock containers cryptonite data-ordlist deepseq
-         directory dlist edit-distance file-embed filepath fsnotify Glob
-         haskeline hspec hspec-discover HUnit language-javascript
-         lifted-async lifted-base memory microlens-platform monad-control
-         monad-logger mtl parallel parsec pattern-arrows process protolude
-         regex-tdfa safe scientific semialign semigroups serialise sourcemap
-         split stm stringsearch syb tasty tasty-golden tasty-hspec
-         tasty-quickcheck text these time transformers transformers-base
-         transformers-compat unordered-containers utf8-string vector
+         directory edit-distance file-embed filepath fsnotify Glob haskeline
+         hspec hspec-discover HUnit language-javascript lifted-async
+         lifted-base memory microlens-platform monad-control monad-logger
+         mtl parallel parsec pattern-arrows process protolude purescript-ast
+         purescript-cst regex-base regex-tdfa safe semialign semigroups
+         serialise sourcemap split stm stringsearch syb tasty tasty-golden
+         tasty-hspec tasty-quickcheck text these time transformers
+         transformers-base transformers-compat unordered-containers
+         utf8-string vector
        ];
        testToolDepends = [ happy hspec-discover ];
        doCheck = false;
···
        broken = true;
      }) {};
 
+  "purescript-ast" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, bytestring, containers
+     , deepseq, filepath, microlens, mtl, protolude, scientific
+     , serialise, text, vector
+     }:
+     mkDerivation {
+       pname = "purescript-ast";
+       version = "0.1.0.0";
+       sha256 = "1zwwbdkc5mb3ckc2g15b18j9vp9bksyc1nrlg73w7w0fzqwnqb4g";
+       libraryHaskellDepends = [
+         aeson base base-compat bytestring containers deepseq filepath
+         microlens mtl protolude scientific serialise text vector
+       ];
+       description = "PureScript Programming Language Abstract Syntax Tree";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "purescript-bridge" = callPackage
     ({ mkDerivation, base, containers, directory, filepath
      , generic-deriving, hspec, hspec-expectations-pretty-diff, lens
···
        ];
        description = "A fast alternative to Purescript's `psc-bundle` to be used during development";
        license = lib.licenses.mit;
+     }) {};
+
+  "purescript-cst" = callPackage
+    ({ mkDerivation, array, base, base-compat, bytestring, containers
+     , dlist, filepath, happy, purescript-ast, scientific, semigroups
+     , tasty, tasty-golden, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "purescript-cst";
+       version = "0.1.0.0";
+       sha256 = "1h4na5k0lz91i1f49axsgs7zqz6dqdxds5dg0g00wd4wmyd619cc";
+       libraryHaskellDepends = [
+         array base containers dlist purescript-ast scientific semigroups
+         text
+       ];
+       libraryToolDepends = [ happy ];
+       testHaskellDepends = [
+         array base base-compat bytestring containers dlist filepath
+         purescript-ast scientific semigroups tasty tasty-golden
+         tasty-quickcheck text
+       ];
+       testToolDepends = [ happy ];
+       description = "PureScript Programming Language Concrete Syntax Tree";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "purescript-iso" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "pusher-http-haskell_2_1_0_0" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , cryptonite, hashable, hspec, http-client, http-client-tls
+     , http-types, memory, QuickCheck, text, time, unordered-containers
+     }:
+     mkDerivation {
+       pname = "pusher-http-haskell";
+       version = "2.1.0.0";
+       sha256 = "1zmcpbd20m7pc1bc0dwkhy33vbakdwc478dmzpr4l80kck0mpmy6";
+       libraryHaskellDepends = [
+         aeson base base16-bytestring bytestring cryptonite hashable
+         http-client http-client-tls http-types memory text time
+         unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson base bytestring hspec QuickCheck text unordered-containers
+       ];
+       description = "Haskell client library for the Pusher Channels HTTP API";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "pusher-ws" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, deepseq
      , hashable, http-conduit, lens, lens-aeson, network, scientific
···
        ];
        description = "Equational laws for free!";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "quickterm" = callPackage
···
 
   "ral" = callPackage
     ({ mkDerivation, adjunctions, base, bin, criterion, deepseq
-     , distributive, fin, hashable, QuickCheck, semigroupoids, vector
+     , distributive, fin, hashable, indexed-traversable, QuickCheck
+     , semigroupoids, vector
      }:
      mkDerivation {
        pname = "ral";
-       version = "0.1";
-       sha256 = "0h8jqaapagrp9faixq817lib8l4nq4ycjj6ppl1ra8llnfsz5304";
-       revision = "2";
-       editedCabalFile = "0a3ryzcmjgyp64f8s2pl95pkz8zddq9qsn76dlimg23gczf1cql4";
+       version = "0.2";
+       sha256 = "0xwr2wr44zzl2bvkii2nq06djd6rrf891zxlb4daxzf3m93xvf3v";
        libraryHaskellDepends = [
-         adjunctions base bin deepseq distributive fin hashable QuickCheck
-         semigroupoids
+         adjunctions base bin deepseq distributive fin hashable
+         indexed-traversable QuickCheck semigroupoids
        ];
        benchmarkHaskellDepends = [ base criterion vector ];
        description = "Random access lists";
···
     ({ mkDerivation, base, bin, fin, lens, ral }:
      mkDerivation {
        pname = "ral-lens";
-       version = "0.1";
-       sha256 = "0hm8mzj51hdql8rp3v0yvmcvmgha4ys8zsgbbx93mlp2b4rfhzpv";
-       revision = "1";
-       editedCabalFile = "0j7lxlbj2klhcx12xixp3glhbvc9k1pccaiqm2kqr5l3lkrcnirv";
+       version = "0.2";
+       sha256 = "0nlw0q0b8bza98h74k0wa2vc9m5bk6g9slri1mzd6cr1pmpvna67";
        libraryHaskellDepends = [ base bin fin lens ral ];
        description = "Length-indexed random access lists: lens utilities";
        license = lib.licenses.gpl2Plus;
···
     ({ mkDerivation, base, bin, fin, optics-core, ral }:
      mkDerivation {
        pname = "ral-optics";
-       version = "0.1";
-       sha256 = "0sky2zbh6wn4xlfc6sbrx7lvvy01qv69j80k0n4w9fyrq9ammb3r";
-       revision = "1";
-       editedCabalFile = "0b2j3iqzbaly8niw3snsmn1z5a34kv4jw8sh3fscsja6zfx0ffgv";
+       version = "0.2";
+       sha256 = "1s7pxkf0vw1a5k1gwyfn6wsmiaa4csbghqshdbva8c73510q0fp1";
        libraryHaskellDepends = [ base bin fin optics-core ral ];
        description = "Length-indexed random access lists: optics utilities";
        license = lib.licenses.gpl2Plus;
···
      }) {};
 
   "rattletrap" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, binary, bytestring
-     , caerbannog, containers, filepath, http-client, http-client-tls
-     , HUnit, scientific, template-haskell, temporary, text
-     , transformers
+    ({ mkDerivation, aeson, aeson-pretty, array, base, binary
+     , bytestring, caerbannog, containers, filepath, http-client
+     , http-client-tls, HUnit, text, transformers
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "9.4.1";
-       sha256 = "1m8bqjqp413sm86v0i2083hnsq7h11hlmmqch1pxbgpv5678jq0q";
+       version = "10.0.7";
+       sha256 = "1wpxysd23gz2lga6bzg3cx21yxjvcprqgk9xqlg3b5gmj22h2mdg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson aeson-pretty base binary bytestring caerbannog containers
-         filepath http-client http-client-tls scientific template-haskell
-         text transformers
+         aeson aeson-pretty array base binary bytestring caerbannog
+         containers filepath http-client http-client-tls text transformers
        ];
        executableHaskellDepends = [ base ];
-       testHaskellDepends = [ base bytestring filepath HUnit temporary ];
+       testHaskellDepends = [ base bytestring filepath HUnit ];
        description = "Parse and generate Rocket League replays";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "record-dot-preprocessor";
-       version = "0.2.8";
-       sha256 = "0ln7kw1f0l56ivzh77s1k1xa3nha3a4hs3bpmdi9apj21ffr5cb6";
+       version = "0.2.9";
+       sha256 = "02g36p14waf66lwwy2s4jy19pmkxv46kqfkkipy7qix3vaffbzir";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base extra ghc uniplate ];
+       executableHaskellDepends = [ base extra ];
+       testHaskellDepends = [ base extra filepath record-hasfield ];
+       description = "Preprocessor to allow record.field syntax";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "record-dot-preprocessor_0_2_10" = callPackage
+    ({ mkDerivation, base, extra, filepath, ghc, record-hasfield
+     , uniplate
+     }:
+     mkDerivation {
+       pname = "record-dot-preprocessor";
+       version = "0.2.10";
+       sha256 = "1zwkc5mqcxlv4cm7qd75sdmvjckvpchcrqphsq82val41mp27nk5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base extra ghc uniplate ];
···
        testHaskellDepends = [ base extra filepath record-hasfield ];
        description = "Preprocessor to allow record.field syntax";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "record-encode" = callPackage
···
        testHaskellDepends = [ base HUnit template-haskell transformers ];
        description = "Representing common recursion patterns as higher-order functions";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "recursion-schemes-ext" = callPackage
···
        ];
        description = "Amateur addenda to recursion-schemes";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "recursion-schemes-ix" = callPackage
···
        libraryHaskellDepends = [ array base regex-base regex-tdfa text ];
        description = "Text interface for regex-tdfa";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "regex-tdfa-unittest" = callPackage
···
      }:
      mkDerivation {
        pname = "rere";
-       version = "0.1";
-       sha256 = "0hskndalxqmlwscvacqmp7gbp8m75a8hnvbifw0hw7hhszlf0yac";
-       revision = "1";
-       editedCabalFile = "0k2fcc94dlcf33by0zcqk01i9k2g8x4j8rnlpfmabld9dvf5cjwg";
+       version = "0.2";
+       sha256 = "0s89flhcmwppypxz909ifmzq7vlwy35yjrbw0gkgm4ikbw6l1ylr";
        libraryHaskellDepends = [
          base containers fin parsec QuickCheck transformers vec
        ];
···
        ];
        description = "Regular-expressions extended with fixpoints for context-free powers";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "rerebase" = callPackage
···
        testHaskellDepends = [ base simple-cmd ];
        description = "Bugzilla query tool";
        license = lib.licenses.gpl2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "rhine" = callPackage
···
        ];
        description = "A library for process pools coupled with asynchronous message queues";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "riot" = callPackage
···
      }:
      mkDerivation {
        pname = "rock";
-       version = "0.3.0.0";
-       sha256 = "1hssz23kifpmcv0vjnrymr4cj1f3m8z7kvvkyzsfh3ysc493514i";
+       version = "0.3.1.0";
+       sha256 = "0rv689w41dbspn40nblkjg81csp5jvk069c92c6dkvfx1biblhwn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Haskell bindings for RocksDB";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) rocksdb;};
 
   "rocksdb-query" = callPackage
···
      }:
      mkDerivation {
        pname = "safe-tensor";
-       version = "0.2.1.0";
-       sha256 = "00s8p7bp72wjpz4mbxn79xg6cllyl2c6fn952w2nykyrapzpxhxm";
+       version = "0.2.1.1";
+       sha256 = "1ms8mrlvvivk474qpa9sqprpr7b8p3l5iq1z58yd81djdkrpqar3";
        libraryHaskellDepends = [
          base constraints containers deepseq hmatrix mtl singletons
        ];
···
      }:
      mkDerivation {
        pname = "scc";
-       version = "0.8.2.4";
-       sha256 = "1f0sayjihh6h7vb4r13j7ly5p0c10biidfmbs9nyybd70ai6dy1f";
+       version = "0.8.3.1";
+       sha256 = "1l89lq20khi3fysbvfxjzchbdw9civz1kj85fyjf8wcm3s3cq34l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "sequence-formats";
-       version = "1.5.2";
-       sha256 = "0n09mw9z8bjqr8dc32l7swp25vgci7m2hb1w6masgv2cw8irh7as";
-       libraryHaskellDepends = [
-         attoparsec base bytestring containers errors exceptions foldl
-         lens-family pipes pipes-attoparsec pipes-bytestring pipes-safe
-         transformers vector
-       ];
-       testHaskellDepends = [
-         base bytestring containers foldl hspec pipes pipes-safe tasty
-         tasty-hunit transformers vector
-       ];
-       description = "A package with basic parsing utilities for several Bioinformatic data formats";
-       license = lib.licenses.gpl3;
-     }) {};
-
-  "sequence-formats_1_6_0" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers, errors
-     , exceptions, foldl, hspec, lens-family, pipes, pipes-attoparsec
-     , pipes-bytestring, pipes-safe, tasty, tasty-hunit, transformers
-     , vector
-     }:
-     mkDerivation {
-       pname = "sequence-formats";
        version = "1.6.0";
        sha256 = "1vy2wwzpnqd2c0ma3jm46gx3w3al0j61ncr22bcahsb1nrgmg0dq";
        libraryHaskellDepends = [
···
        ];
        description = "A package with basic parsing utilities for several Bioinformatic data formats";
        license = lib.licenses.gpl3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sequenceTools" = callPackage
···
        ];
        description = "Embed a directory of static files in your Servant server";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "servant-streaming" = callPackage
···
        ];
        description = "Invertible grammar combinators for S-expressions";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sexp-show" = callPackage
···
        ];
        description = "Dependency tracking for Futhark";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "shake-google-closure-compiler" = callPackage
···
      }) {};
 
   "simple-units" = callPackage
-    ({ mkDerivation, base, first-class-families }:
+    ({ mkDerivation, base, doctest, first-class-families }:
      mkDerivation {
        pname = "simple-units";
-       version = "1.0.1.1";
-       sha256 = "1dzsr15lq32dqsbhb639vzlx2d6m2kx0qax75ik2z765r5h9f9sa";
+       version = "1.0.2";
+       sha256 = "1caijdnah0lr5c48zmx93b06yvw9fbpakw0y0nz0k4icv935xdam";
        libraryHaskellDepends = [ base first-class-families ];
+       testHaskellDepends = [ base doctest ];
        description = "Simple arithmetic with SI units using type-checked dimensional analysis";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "skylighting";
-       version = "0.10.3";
-       sha256 = "0bhy0y3d8czv2m92snbqqh5b8xywf74xwc1qml98vy6im0s545ad";
+       version = "0.10.4";
+       sha256 = "057nrlm714r78rfdrqyy4zjl50npvz5qaprrb9nfwdiyb50nyz2j";
        configureFlags = [ "-fexecutable" ];
        isLibrary = true;
        isExecutable = true;
···
     ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
      , base64-bytestring, binary, blaze-html, bytestring
      , case-insensitive, colour, containers, criterion, Diff, directory
-     , filepath, HUnit, hxt, mtl, pretty-show, QuickCheck, random, safe
+     , filepath, HUnit, mtl, pretty-show, QuickCheck, random, safe
      , tasty, tasty-golden, tasty-hunit, tasty-quickcheck, text
-     , transformers, utf8-string
+     , transformers, utf8-string, xml-conduit
      }:
      mkDerivation {
        pname = "skylighting-core";
-       version = "0.10.3";
-       sha256 = "00avd17l2fqvss2cnndmina3vp809x784gdyaf1bwmkcsfnl8d3c";
+       version = "0.10.4";
+       sha256 = "0b5cbwsr5mnl4wppxw8rwy4a14pk6s804c4qwf1cd2vzz9j64dag";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson ansi-terminal attoparsec base base64-bytestring binary
          blaze-html bytestring case-insensitive colour containers directory
-         filepath hxt mtl safe text transformers utf8-string
+         filepath mtl safe text transformers utf8-string xml-conduit
        ];
        testHaskellDepends = [
          aeson base bytestring containers Diff directory filepath HUnit
···
      }:
      mkDerivation {
        pname = "slack-web";
-       version = "0.2.1.0";
-       sha256 = "01bwiq3b97bznn3sc51vi7q8xkjdslvqqh250fk7arcaq6hkkiw1";
+       version = "0.3.0.0";
+       sha256 = "1z223dhv0qb7labrxppjq65lp2jyscxgxk4rjdvfd2xsglj36dbf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Convert text into slugs";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "slynx" = callPackage
···
        ];
        description = "Support for the Sockets and Pipes book";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "socketson" = callPackage
···
      }:
      mkDerivation {
        pname = "sparse-tensor";
-       version = "0.2.1.4";
-       sha256 = "10caf86g33hcccmpicxfjh0jq3z9d7vs4jafl0f8zhy09dirq8bn";
+       version = "0.2.1.5";
+       sha256 = "0549hw502hka1fyvv00nvd5aif5knvq7b9fk62f3fyjlfmqcnwx4";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          ad base bytestring cereal containers deepseq ghc-typelits-knownnat
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "stache_2_2_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, criterion
+     , deepseq, directory, file-embed, filepath, gitrev, hspec
+     , hspec-discover, hspec-megaparsec, megaparsec, mtl
+     , optparse-applicative, template-haskell, text
+     , unordered-containers, vector, yaml
+     }:
+     mkDerivation {
+       pname = "stache";
+       version = "2.2.1";
+       sha256 = "1vkvi9rrf15a8lbihvcmrslykby4qc4jmc5zaqm1ikxsid9x5704";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers deepseq directory filepath
+         megaparsec mtl template-haskell text unordered-containers vector
+       ];
+       executableHaskellDepends = [
+         aeson base filepath gitrev optparse-applicative text
+         unordered-containers yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers file-embed hspec hspec-megaparsec
+         megaparsec template-haskell text yaml
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         aeson base criterion deepseq megaparsec text
+       ];
+       description = "Mustache templates for Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "stack" = callPackage
     ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, array
      , async, attoparsec, base, base64-bytestring, bytestring, Cabal
···
        ];
        description = "Program to fold GHC prof files into flamegraph input";
        license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "stacked-dag" = callPackage
···
        ];
        description = "GHC.Generics style staged generics";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "stagen" = callPackage
···
      }:
      mkDerivation {
        pname = "streaming-cassava";
-       version = "0.1.0.1";
-       sha256 = "0dr58azgyw7ihxrabva7fh0yafq2kx12yvap4jl6ljnlwvcapa5i";
+       version = "0.2.0.0";
+       sha256 = "07mlhnn2k8zdgc5lrv0icyr4nn83dc0grywr5q284y64irix6grl";
        libraryHaskellDepends = [
          base bytestring cassava mtl streaming streaming-bytestring
          transformers
···
      }:
      mkDerivation {
        pname = "streamly";
-       version = "0.7.2";
-       sha256 = "007i3rfza0v8zy34lq9ipq2biarg82prmd1vxr5f2zz5xln37wrm";
-       revision = "1";
-       editedCabalFile = "15fyfvf0g2l678426fz91fqf3qgi44dagqdxh6i6am3vh0nvvg1d";
+       version = "0.7.3";
+       sha256 = "11bjyyqc745igw7122284fjph0922l56jddnhfy5h7w84nj35ck3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Folder watching as a Streamly stream";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "streamly-lmdb" = callPackage
···
        broken = true;
      }) {};
 
+  "strict-tuple-lens_0_2" = callPackage
+    ({ mkDerivation, base, lens, strict-tuple }:
+     mkDerivation {
+       pname = "strict-tuple-lens";
+       version = "0.2";
+       sha256 = "02pagvg6rz0bdkxvikv7ac7766b329j84jbd42cjqr193wjphqd4";
+       libraryHaskellDepends = [ base lens strict-tuple ];
+       description = "Optics for the `strict-tuple` library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "strict-types" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, deepseq
      , hashable, text, unordered-containers, vector
···
        broken = true;
      }) {};
 
+  "sublists" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "sublists";
+       version = "0.1.1.0";
+       sha256 = "1k08cpidl5r4sj64vc1a9fcln78k31z7v8gnh579fxa5lrp4ylnr";
+       libraryHaskellDepends = [ base ];
+       description = "Allows to split lists into sublists with some patterns by quantity";
+       license = lib.licenses.mit;
+     }) {};
+
   "submark" = callPackage
     ({ mkDerivation, base, cmark, hlint, hspec, optparse-applicative
      , template-haskell, text
···
        pname = "svg-builder";
        version = "0.1.1";
        sha256 = "1k420f497lzkymmxin88ql6ib8dziic43avykv31yq65rgrf7l2g";
-       revision = "2";
-       editedCabalFile = "100nmkgcm1ncv4mkr1xcsa7bb3z6zx0lfayk8innd4hm62xsvhj3";
+       revision = "3";
+       editedCabalFile = "1zc7shja5i63rn7kd9mnq2m052qhp7nh44qy8qp93dm64v9m9pi2";
        libraryHaskellDepends = [
          base blaze-builder bytestring hashable text unordered-containers
        ];
···
        pname = "svg-tree";
        version = "0.6.2.4";
        sha256 = "1hhs2w6fmd1m6768p1bfhj6vi4br4ray0g9f1hv8g19pqgip3r2c";
+       revision = "1";
+       editedCabalFile = "12askkxmrzjkssnfa8m6xmdwdxk6v3z26jc63jcgb3q8snxb0hg1";
        libraryHaskellDepends = [
          attoparsec base bytestring containers JuicyPixels lens linear mtl
          scientific text transformers vector xml
···
     ({ mkDerivation, base, containers, deepseq, tasty }:
      mkDerivation {
        pname = "tasty-bench";
-       version = "0.2.1";
-       sha256 = "0gw0hlpkpwn7hpvwn9i8zqghrzjvhdrhr2q9y4r4ykhqv7y95zy3";
-       libraryHaskellDepends = [ base containers deepseq tasty ];
-       description = "Featherlight benchmark framework";
-       license = lib.licenses.mit;
-     }) {};
-
-  "tasty-bench_0_2_2" = callPackage
-    ({ mkDerivation, base, containers, deepseq, tasty }:
-     mkDerivation {
-       pname = "tasty-bench";
        version = "0.2.2";
        sha256 = "0x6kg8n778nysv3b7j31bnh62h5srid35nhmvr76bzba4qdgx258";
        libraryHaskellDepends = [ base containers deepseq tasty ];
        description = "Featherlight benchmark framework";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tasty-dejafu" = callPackage
···
        ];
        description = "Render tasty output to HTML";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "tasty-hunit" = callPackage
···
        broken = true;
      }) {};
 
+  "terraform-http-backend-pass" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, directory, mtl
+     , optparse-applicative, optparse-generic, servant, servant-server
+     , shelly, text, warp
+     }:
+     mkDerivation {
+       pname = "terraform-http-backend-pass";
+       version = "0.1.0.0";
+       sha256 = "0cw9vzj5kigz84r2nwxmvva5fmn9r6y78g40icwi1yaby9g9s809";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring directory mtl optparse-applicative
+         optparse-generic servant servant-server shelly text warp
+       ];
+       executableHaskellDepends = [ base ];
+       description = "HTTP backend to store terraform state using pass and git";
+       license = "AGPL";
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "terrahs" = callPackage
     ({ mkDerivation, base, haskell98, old-time, terralib4c, translib }:
      mkDerivation {
···
      }) {};
 
   "text-ascii" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, hashable, optics-core
-     , parsec, template-haskell, text
+    ({ mkDerivation, base, bytestring, case-insensitive, deepseq
+     , hashable, megaparsec, optics-core, optics-extra, template-haskell
+     , text
      }:
      mkDerivation {
        pname = "text-ascii";
-       version = "1.0.0";
-       sha256 = "1mwm3ss54c927rdj8dlfw7v2l0maz12mkxb5ss3g1ngdkiwd0bsx";
+       version = "1.0.1";
+       sha256 = "0clibcn3g72hxjhcsnb7ziw35ald5zqkql5b8mf9lpjpx94hii65";
+       revision = "1";
+       editedCabalFile = "0qc1in7i9i22hyd440g3bra74ryz26z8c2bcxdbr91hfjzj4n3g3";
        libraryHaskellDepends = [
-         base bytestring deepseq hashable optics-core parsec
-         template-haskell text
+         base bytestring case-insensitive deepseq hashable megaparsec
+         optics-core optics-extra template-haskell text
        ];
        description = "ASCII string and character processing";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "text-binary" = callPackage
···
     ({ mkDerivation, base, lens, these }:
      mkDerivation {
        pname = "these-lens";
-       version = "1.0.1.1";
-       sha256 = "1nwknm17x7vkx9936z7xa6hqw69pgig185if1dninrvyxvv59kps";
-       libraryHaskellDepends = [ base lens these ];
-       description = "Lenses for These";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "these-lens_1_0_1_2" = callPackage
-    ({ mkDerivation, base, lens, these }:
-     mkDerivation {
-       pname = "these-lens";
        version = "1.0.1.2";
        sha256 = "1v3kj7j4bkywbmdbblwqs5gsj5s23d59sb3s27jf3bwdzf9d21p6";
        libraryHaskellDepends = [ base lens these ];
        description = "Lenses for These";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "these-optics" = callPackage
     ({ mkDerivation, base, optics-core, these }:
      mkDerivation {
        pname = "these-optics";
-       version = "1.0.1.1";
-       sha256 = "1xwf2m03cbb2z40mdab70d042nmvcxpgdq94rmajbqqpb072yivq";
-       libraryHaskellDepends = [ base optics-core these ];
-       description = "Optics for These";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "these-optics_1_0_1_2" = callPackage
-    ({ mkDerivation, base, optics-core, these }:
-     mkDerivation {
-       pname = "these-optics";
        version = "1.0.1.2";
        sha256 = "06jxv320a8f94zjjsqrh072vz2dkzhwgcmpbdy1prgvypiynm4zd";
        libraryHaskellDepends = [ base optics-core these ];
        description = "Optics for These";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "these-skinny" = callPackage
···
      }:
      mkDerivation {
        pname = "tidal";
-       version = "1.7.1";
-       sha256 = "0fksrydrmjph3ghggijr9hq3xa5wfnqgzm4qxiqravsj70s9m2n4";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bifunctors bytestring clock colour containers deepseq hosc
-         network parsec primitive random text transformers vector
-       ];
-       testHaskellDepends = [
-         base containers deepseq hosc microspec parsec
-       ];
-       benchmarkHaskellDepends = [ base criterion weigh ];
-       description = "Pattern language for improvised music";
-       license = lib.licenses.gpl3;
-     }) {};
-
-  "tidal_1_7_2" = callPackage
-    ({ mkDerivation, base, bifunctors, bytestring, clock, colour
-     , containers, criterion, deepseq, hosc, microspec, network, parsec
-     , primitive, random, text, transformers, vector, weigh
-     }:
-     mkDerivation {
-       pname = "tidal";
        version = "1.7.2";
        sha256 = "15shxaazxik1bawgak16xhlvk708kv9al6i3518b3m3iap9sbw9p";
        enableSeparateDataOutput = true;
···
        benchmarkHaskellDepends = [ base criterion weigh ];
        description = "Pattern language for improvised music";
        license = lib.licenses.gpl3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tidal-midi" = callPackage
···
        pname = "time-parsers";
        version = "0.1.2.1";
        sha256 = "102k6l9888kbgng045jk170qjbmdnwv2lbzlc12ncybfk2yk7wdv";
-       revision = "2";
-       editedCabalFile = "10bawg6cwfwm31fcs63z8imd1cdl1wq8syn669yfkycrk77wfkli";
+       revision = "3";
+       editedCabalFile = "1cv9fpn8bixicwcacyv0hx81q1xw06pig07zrpnf354bqzrsf3jw";
        libraryHaskellDepends = [ base parsers template-haskell time ];
        testHaskellDepends = [
          attoparsec base bifunctors parsec parsers tasty tasty-hunit
···
      }:
      mkDerivation {
        pname = "too-many-cells";
-       version = "2.1.0.1";
-       sha256 = "0clrkr7kxcky6l1gwnbznz013svn7254n8fkkb7mgvn93h94anky";
+       version = "2.1.1.0";
+       sha256 = "0ysixw2ab0m2gmh7aqn2qhrc5gb6habjdif7f2bf7a1n29rih8x6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Type-level and typed unary natural numbers, inequality proofs, vectors";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "typeable-th" = callPackage
···
        ];
        description = "Usage examples for the uniqueness-periods-vector series of packages";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "uniqueness-periods-vector-filters" = callPackage
···
        ];
        description = "Metrices for the maximum element for the uniqueness-periods-vector packages family";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "uniqueness-periods-vector-stats" = callPackage
···
        benchmarkHaskellDepends = [ base criterion dir-traverse ];
        description = "Fast and flexible primitives for recursive file system IO on Posix systems";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "unix-simple" = callPackage
···
        ];
        description = "Fast and robust message queues for concurrent processes";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "unliftio-path" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "validation_1_1_1" = callPackage
+    ({ mkDerivation, assoc, base, bifunctors, deepseq, hedgehog, HUnit
+     , lens, semigroupoids, semigroups
+     }:
+     mkDerivation {
+       pname = "validation";
+       version = "1.1.1";
+       sha256 = "1dv7azpljdcf7irbnznnz31hq611bn1aj2m6ywghz3hgv835qqak";
+       libraryHaskellDepends = [
+         assoc base bifunctors deepseq lens semigroupoids semigroups
+       ];
+       testHaskellDepends = [ base hedgehog HUnit lens semigroups ];
+       description = "A data-type like Either but with an accumulating Applicative";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "validation-selective" = callPackage
     ({ mkDerivation, base, deepseq, doctest, hedgehog, hspec
      , hspec-hedgehog, selective, text
···
 
   "vec" = callPackage
     ({ mkDerivation, adjunctions, base, base-compat, criterion, deepseq
-     , distributive, fin, hashable, inspection-testing, QuickCheck
-     , semigroupoids, tagged, transformers, vector
+     , distributive, fin, hashable, indexed-traversable
+     , inspection-testing, QuickCheck, semigroupoids, tagged
+     , transformers, vector
      }:
      mkDerivation {
        pname = "vec";
-       version = "0.3";
-       sha256 = "0r2jk3jqwn0r4wnpgc8k8i664g3rrs6dkyfsysysn4w10j22j5sr";
-       revision = "2";
-       editedCabalFile = "0v9m2x1p1395dqf0g2agfgmlx6w1dak2fr50hh6aahjk4y0jp30j";
+       version = "0.4";
+       sha256 = "0z7icj5g59ml8cmcawa6ncayrzdi63s9ssllvnw2dfcd3ys5cjj0";
        libraryHaskellDepends = [
-         adjunctions base deepseq distributive fin hashable QuickCheck
-         semigroupoids transformers
+         adjunctions base deepseq distributive fin hashable
+         indexed-traversable QuickCheck semigroupoids transformers
        ];
        testHaskellDepends = [
          base base-compat fin inspection-testing tagged
···
     ({ mkDerivation, base, fin, lens, vec }:
      mkDerivation {
        pname = "vec-lens";
-       version = "0.3";
-       sha256 = "0i08p7rfmivf03mir7hcbkr7rarji95icsyvi6diclav1jd6fa7q";
-       revision = "1";
-       editedCabalFile = "0grj1abb7gjbzw06672464r75wjnmra9d12yvlmdm1qyj9zya0ph";
+       version = "0.4";
+       sha256 = "1qjv8wg6b8wbldvripn84vyw5cgpcpgh2v6v1nk7pzwrn99lfb7h";
        libraryHaskellDepends = [ base fin lens vec ];
        description = "Vec: length-indexed (sized) list: lens support";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, fin, optics-core, vec }:
      mkDerivation {
        pname = "vec-optics";
-       version = "0.3";
-       sha256 = "13g0j9hn27jfjlrm7c6bdsb2lhwrg016cal7hdic8azdxgdp8n0a";
-       revision = "1";
-       editedCabalFile = "10abn334qhbik8s8lx1r54vcbj3d2s091j2w98mq3cllksa8dmv0";
+       version = "0.4";
+       sha256 = "0vdpxkmhiqbql68rkrfaci6c6n7sbr49p08q0jj6cvbmjy3aa1lg";
        libraryHaskellDepends = [ base fin optics-core vec ];
        description = "Vec: length-indexed (sized) list: optics support";
        license = lib.licenses.bsd3;
···
        testHaskellDepends = [ base doctest hedgehog hedgehog-classes ];
        description = "circular vectors";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "vector-clock" = callPackage
···
      }:
      mkDerivation {
        pname = "verifiable-expressions";
-       version = "0.6.0";
-       sha256 = "1drb5zkpm5zn765fkp2p7jq69q50f9577rz9bs76cp0gvccan8my";
+       version = "0.6.1";
+       sha256 = "0s3615m849xj0df6ia18kg4i54z87x3c6yxgv594dwf9mf9dw4x8";
        libraryHaskellDepends = [
          base containers lens mtl sbv transformers union vinyl
        ];
···
        libraryHaskellDepends = [ base random vector vector-fftw ];
        description = "Phase vocoder";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "vocoder-audio" = callPackage
···
        ];
        description = "Phase vocoder for conduit-audio";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "vocoder-conduit" = callPackage
···
        ];
        description = "Phase vocoder for Conduit";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "vocoder-dunai" = callPackage
···
        ];
        description = "Phase vocoder for Dunai and Rhine";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "voicebase" = callPackage
···
      }:
      mkDerivation {
        pname = "vulkan-utils";
-       version = "0.4.2";
-       sha256 = "0mf1jf5xv31818c7rarvz0aqc1qxgh7fqfp893pryhwwcr8r2qqa";
+       version = "0.5.0";
+       sha256 = "11pcxa7pjhdrfcxl058dn909ar6sv9kn34g73w8jqa60d2savj6q";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bytestring containers dependent-map dependent-sum extra
···
 
   "wai-secure-cookies" = callPackage
     ({ mkDerivation, base, bytestring, cryptonite, hspec
-     , hspec-expectations, hspec-wai, http-types, memory, protolude
-     , random, split, wai, wai-extra
+     , hspec-expectations, hspec-wai, http-types, memory, random, split
+     , wai, wai-extra
      }:
      mkDerivation {
        pname = "wai-secure-cookies";
-       version = "0.1.0.5";
-       sha256 = "0v3gz70z968yk563g9n72v8l7mhqhkbjb9gy15s5zpf3apv1cf00";
+       version = "0.1.0.6";
+       sha256 = "02y2vw3mw3k6il7x6dfcs1fhzzbaslxk374nj4yqwzr6ax4nvrgb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base bytestring cryptonite http-types memory protolude random split
-         wai
+         base bytestring cryptonite http-types memory random split wai
        ];
        executableHaskellDepends = [ base bytestring cryptonite memory ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "xlsx";
-       version = "0.8.2";
-       sha256 = "0kjfnp24nc97qqla1z65wzy59cch336pjncz1kdfakmgv27mv38a";
-       libraryHaskellDepends = [
-         attoparsec base base64-bytestring binary-search bytestring conduit
-         containers data-default deepseq errors extra filepath lens mtl
-         network-uri old-locale safe text time transformers vector xeno
-         xml-conduit zip-archive zlib
-       ];
-       testHaskellDepends = [
-         base bytestring containers Diff groom lens mtl raw-strings-qq
-         smallcheck tasty tasty-hunit tasty-smallcheck text time vector
-         xml-conduit
-       ];
-       benchmarkHaskellDepends = [ base bytestring criterion ];
-       description = "Simple and incomplete Excel file parser/writer";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "xlsx_0_8_3" = callPackage
-    ({ mkDerivation, attoparsec, base, base64-bytestring, binary-search
-     , bytestring, conduit, containers, criterion, data-default, deepseq
-     , Diff, errors, extra, filepath, groom, lens, mtl, network-uri
-     , old-locale, raw-strings-qq, safe, smallcheck, tasty, tasty-hunit
-     , tasty-smallcheck, text, time, transformers, vector, xeno
-     , xml-conduit, zip-archive, zlib
-     }:
-     mkDerivation {
-       pname = "xlsx";
        version = "0.8.3";
        sha256 = "11g6bfir21wgafnkzzx26r6mz8m39isaz2yqw92k5ymdb1qhs95q";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base bytestring criterion ];
        description = "Simple and incomplete Excel file parser/writer";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "xlsx-tabular" = callPackage
···
 
   "xml-conduit" = callPackage
     ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
-     , bytestring, conduit, conduit-extra, containers
-     , data-default-class, deepseq, doctest, hspec, HUnit, resourcet
-     , text, transformers, xml-types
+     , bytestring, Cabal, cabal-doctest, conduit, conduit-extra
+     , containers, data-default-class, deepseq, doctest, hspec, HUnit
+     , resourcet, text, transformers, xml-types
      }:
      mkDerivation {
        pname = "xml-conduit";
-       version = "1.9.0.0";
-       sha256 = "1p57v127882rxvvmwjmvnqdmk3x2wg1z4d8y03849h0xaz1vid0w";
+       version = "1.9.1.0";
+       sha256 = "0ag0g9x5qnw1nfgc31h6bj2qv0h1c2y7n1l0g99l4dkn428dk9ca";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          attoparsec base blaze-html blaze-markup bytestring conduit
          conduit-extra containers data-default-class deepseq resourcet text
···
        description = "Streaming XML parser based on conduits";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "xml-conduit-selectors" = callPackage
+    ({ mkDerivation, base, containers, data-default, megaparsec, tasty
+     , tasty-hunit, tasty-quickcheck, text, xml-conduit
+     }:
+     mkDerivation {
+       pname = "xml-conduit-selectors";
+       version = "0.2.0.0";
+       sha256 = "1h1gfnsrypy9w559rgbgabidzpaw580xy0m6l12bbcjc92kr3mf0";
+       libraryHaskellDepends = [
+         base containers megaparsec text xml-conduit
+       ];
+       testHaskellDepends = [
+         base containers data-default tasty tasty-hunit tasty-quickcheck
+         text xml-conduit
+       ];
+       description = "jQuery-style CSS selectors for xml-conduit";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "xml-conduit-stylist" = callPackage
···
        doHaddock = false;
        description = "A wrapper around Yahoo API for downloading market data";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "yahoo-web-search" = callPackage
···
        testToolDepends = [ tasty-discover ];
        description = "Yet another string interpolator";
        license = lib.licenses.cc0;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "yate" = callPackage
···
      }:
      mkDerivation {
        pname = "yesod-auth-lti13";
-       version = "0.2.0.0";
-       sha256 = "0g48g1ajzwp7k7q3vi1z4nvmmvcfiyziizfydnd3i26xf7nvzqnx";
+       version = "0.2.0.1";
+       sha256 = "1ylwg85q6j04rmq0lclyiv7by3dgwmpya5hv1dqhaw62nlfh05r6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
-  "yesod-auth-oauth2_0_6_2_2" = callPackage
+  "yesod-auth-oauth2_0_6_2_3" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cryptonite, errors
      , hoauth2, hspec, http-client, http-conduit, http-types, memory
      , microlens, safe-exceptions, text, uri-bytestring, yesod-auth
···
      }:
      mkDerivation {
        pname = "yesod-auth-oauth2";
-       version = "0.6.2.2";
-       sha256 = "176iz5mg9jhrp8kp61f12j1jw3icnqp10dxln7046p1nqam0nv3d";
+       version = "0.6.2.3";
+       sha256 = "1vf4cfbqg4zx3rdihj1iajk6kmj9c8xk4s4n2n40yvz2rmbjy0yb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "yesod-markdown";
-       version = "0.12.6.3";
-       sha256 = "1q2zbb49248ppda5k5lxqnq8s5yf1mym05jwna59m0kfxp63xbj5";
+       version = "0.12.6.5";
+       sha256 = "1bs0npryigf7k8gj48i8r8snylc49qdca96610msi6df843c6s6g";
        libraryHaskellDepends = [
          base blaze-html blaze-markup bytestring directory pandoc persistent
          shakespeare text xss-sanitize yesod-core yesod-form
···
      }) {};
 
   "yesod-page-cursor" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, hspec
-     , hspec-expectations-lifted, http-link-header, http-types, lens
-     , lens-aeson, monad-logger, mtl, network-uri, persistent
-     , persistent-sqlite, persistent-template, scientific, text, time
-     , unliftio, unliftio-core, wai-extra, yesod, yesod-core, yesod-test
-     }:
-     mkDerivation {
-       pname = "yesod-page-cursor";
-       version = "2.0.0.3";
-       sha256 = "1qj3qsrzjh0w0hc9ngbxd82pkwb8jylhf0nihhnk4dvrdqm2yvyb";
-       libraryHaskellDepends = [
-         aeson base bytestring containers http-link-header network-uri text
-         unliftio yesod-core
-       ];
-       testHaskellDepends = [
-         aeson base bytestring hspec hspec-expectations-lifted
-         http-link-header http-types lens lens-aeson monad-logger mtl
-         persistent persistent-sqlite persistent-template scientific text
-         time unliftio unliftio-core wai-extra yesod yesod-core yesod-test
-       ];
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "yesod-page-cursor_2_0_0_4" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, hspec
      , hspec-expectations-lifted, http-link-header, http-types, lens
      , lens-aeson, monad-logger, mtl, network-uri, persistent
···
      }:
      mkDerivation {
        pname = "zip-stream";
-       version = "0.2.0.1";
-       sha256 = "11x58s5w1lr8hw86grxijd94sw5r8k376b8n4dlm8lqz5xhmri5p";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base binary binary-conduit bytestring conduit conduit-extra digest
-         exceptions mtl primitive resourcet text time transformers-base zlib
-       ];
-       executableHaskellDepends = [
-         base bytestring conduit conduit-extra directory filepath resourcet
-         text time transformers
-       ];
-       description = "ZIP archive streaming using conduits";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "zip-stream_0_2_1_0" = callPackage
-    ({ mkDerivation, base, binary, binary-conduit, bytestring, conduit
-     , conduit-extra, digest, directory, exceptions, filepath, mtl
-     , primitive, resourcet, text, time, transformers, transformers-base
-     , zlib
-     }:
-     mkDerivation {
-       pname = "zip-stream";
        version = "0.2.1.0";
        sha256 = "0fx8kj0ijm3555grhdns7agmi084584fh1v0mvkm4x696h1zzvli";
        isLibrary = true;
···
        ];
        description = "ZIP archive streaming using conduits";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "zipedit" = callPackage