Merge staging-next into staging

nixos/modules/services/x11/display-managers/default.nix

···
         done
 
         if test -d ${pkg}/share/xsessions; then
-          ${xorg.lndir}/bin/lndir ${pkg}/share/xsessions $out/share/xsessions
+          ${pkgs.buildPackages.xorg.lndir}/bin/lndir ${pkg}/share/xsessions $out/share/xsessions
         fi
         if test -d ${pkg}/share/wayland-sessions; then
-          ${xorg.lndir}/bin/lndir ${pkg}/share/wayland-sessions $out/share/wayland-sessions
+          ${pkgs.buildPackages.xorg.lndir}/bin/lndir ${pkg}/share/wayland-sessions $out/share/wayland-sessions
         fi
       '') cfg.displayManager.sessionPackages}
     '';

nixos/modules/system/boot/systemd-lib.nix

···
 
 let
   cfg = config.systemd;
-  lndir = "${pkgs.xorg.lndir}/bin/lndir";
+  lndir = "${pkgs.buildPackages.xorg.lndir}/bin/lndir";
 in rec {
 
   shellEscape = s: (replaceChars [ "\\" ] [ "\\\\" ] s);

pkgs/data/fonts/recursive/default.nix

···
 { lib, fetchzip }:
 
 let
-  version = "1.079";
+  version = "1.082";
 in
 fetchzip {
   name = "recursive-${version}";
···
     unzip -j $downloadedFile \*.ttf -d $out/share/fonts/truetype
   '';
 
-  sha256 = "sha256-nRFjfbbZG9wDHGbGfS+wzViKF/ogWs8i/6OG0rkDHDg=";
+  sha256 = "1hjyjvzhfgqw58py4gk58fwyp5pxr3j8j76ppj6apg4dndfhs0lp";
 
   meta = with lib; {
     homepage = "https://recursive.design/";

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "73463ac080cd55650580d58fe80e5b2dcdfe5a7e",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/73463ac080cd55650580d58fe80e5b2dcdfe5a7e.tar.gz",
-  "sha256": "1vwlpkrpfj6wdzlv4lwargyakyci81gri70z2jhkpvv3l6adc0gk",
-  "msg": "Update from Hackage at 2021-10-15T10:42:20Z"
+  "commit": "b60d5f4b773d16857c105718faad9699e145edcd",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/b60d5f4b773d16857c105718faad9699e145edcd.tar.gz",
+  "sha256": "19avxynbjhkhvjy5kcxgd3fp0b2nczsk213s1za488r6kksj90f5",
+  "msg": "Update from Hackage at 2021-10-18T14:27:09Z"
 }

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

···
   # These packages (and their reverse deps) cannot be built with profiling enabled.
   ghc-heap-view = disableLibraryProfiling super.ghc-heap-view;
   ghc-datasize = disableLibraryProfiling super.ghc-datasize;
+  ghc-vis = disableLibraryProfiling super.ghc-vis;
 
   # This test keeps being aborted because it runs too quietly for too long
   Lazy-Pbkdf2 = if pkgs.stdenv.isi686 then dontCheck super.Lazy-Pbkdf2 else super.Lazy-Pbkdf2;
···
   gi-cairo-render = doJailbreak super.gi-cairo-render;
   gi-cairo-connector = doJailbreak super.gi-cairo-connector;
 
-  svgcairo = overrideCabal super.svgcairo (drv: {
-    patches = [
-      # Remove when https://github.com/gtk2hs/svgcairo/pull/10 gets merged.
-      (pkgs.fetchpatch {
-        url = "https://github.com/gtk2hs/svgcairo/commit/df6c6172b52ecbd32007529d86ba9913ba001306.patch";
-        sha256 = "128qrns56y139vfzg1rbyqfi2xn8gxsmpnxv3zqf4v5spsnprxwh";
-      })
-      # The update here breaks svgcairo:
-      # https://github.com/NixOS/nixpkgs/commit/08fcd73d9dc9a28aa901210b259d9bfb3c228018
-      # and updating the call to the header with the correct name fixes it.
-      (pkgs.fetchpatch {
-        url = "https://github.com/dalpd/svgcairo/commit/4dc6d8d3a6c24be0b8c1fd73b282ff247e7b1e6f.patch";
-        sha256 = "1pq9ld9z67zsxj8vqjf82qwckcp69lvvnrjb7wsyb5jc6jaj3q0a";
-      })
-    ];
-  });
+  svgcairo = appendPatches super.svgcairo [
+    # Remove when https://github.com/gtk2hs/svgcairo/pull/12 goes in.
+    (pkgs.fetchpatch {
+      url = "https://github.com/gtk2hs/svgcairo/commit/348c60b99c284557a522baaf47db69322a0a8b67.patch";
+      sha256 = "0akhq6klmykvqd5wsbdfnnl309f80ds19zgq06sh1mmggi54dnf3";
+    })
+    # Remove when https://github.com/gtk2hs/svgcairo/pull/13 goes in.
+    (pkgs.fetchpatch {
+      url = "https://github.com/dalpd/svgcairo/commit/d1e0d7ae04c1edca83d5b782e464524cdda6ae85.patch";
+      sha256 = "1pq9ld9z67zsxj8vqjf82qwckcp69lvvnrjb7wsyb5jc6jaj3q0a";
+    })
+  ];
 
   # Missing -Iinclude parameter to doc-tests (pull has been accepted, so should be resolved when 0.5.3 released)
   # https://github.com/lehins/massiv/pull/104
···
     cabal-install-parsers = self.cabal-install-parsers_0_4_2;
   };
 
+  # Build haskell-ci from git repository, including some useful fixes,
+  # e. g. required for generating the workflows for the cabal2nix repository
+  haskell-ci-unstable = (overrideSrc super.haskell-ci {
+    version = "0.13.20211011";
+    src = pkgs.fetchFromGitHub {
+      owner = "haskell-CI";
+      repo = "haskell-ci";
+      rev = "c88e67e675bc4a990da53863c7fb42e67bcf9847";
+      sha256 = "1zhv1cg047lfyxfs3mvc73vv96pn240zaj7f2yl4lw5yj6y5rfk9";
+    };
+  }).overrideScope (self: super: {
+    attoparsec = self.attoparsec_0_14_1;
+    Cabal = self.Cabal_3_6_2_0;
+  });
+
   Frames-streamly = overrideCabal (super.Frames-streamly.override { relude = super.relude_1_0_0_1; }) (drv: {
     # https://github.com/adamConnerSax/Frames-streamly/issues/1
     patchPhase = ''
···
   # Fixes https://github.com/NixOS/nixpkgs/issues/140613
   # https://github.com/recursion-schemes/recursion-schemes/issues/128
   recursion-schemes = appendPatch super.recursion-schemes ./patches/recursion-schemes-128.patch;
+
+  # Fix from https://github.com/brendanhay/gogol/pull/144 which has seen no release
+  # Can't use fetchpatch as it required tweaking the line endings as the .cabal
+  # file revision on hackage was gifted CRLF line endings
+  gogol-core = appendPatch super.gogol-core ./patches/gogol-core-144.patch;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   weeder = self.weeder_2_3_0;
   generic-lens-core = self.generic-lens-core_2_2_0_0;
   generic-lens = self.generic-lens_2_2_0_0;
+  th-desugar = self.th-desugar_1_12;
+  autoapply = self.autoapply_0_4_1_1;
 
   # Doesn't allow Dhall 1.39.*
   weeder_2_3_0 = super.weeder_2_3_0.override {

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

···
   # Tests fail because of typechecking changes
   conduit = dontCheck super.conduit;
 
-  constraints = appendPatch super.constraints (pkgs.fetchpatch {
+  constraints = appendPatch (doJailbreak super.constraints) (pkgs.fetchpatch {
     url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/constraints-0.13.patch";
     sha256 = "0cr4qzw0fbwy97f3wx0v3mv8yc642ahpfa80kaqrq191232fzzf3";
   });

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

···
   - event-driven
   - eventful-dynamodb
   - eventful-sql-common
-  - eventlog2html
   - eventloop
   - eventstore
   - ewe
···
   - ez-couch
   - Facebook-Password-Hacker-Online-Latest-Version
   - faceted
+  - factory
   - facts
   - fadno-braids
   - failable-list
···
   - fingertree-tf
   - finitary-derive
   - firefly-example
+  - firestore
   - first-and-last
   - first-class-instances
   - fit
···
   - ghc-tcplugin-api
   - ghc-time-alloc-prof
   - ghc-usage
-  - ghc-vis
   - gh-labeler
   - giak
   - Gifcurry
···
   - gochan
   - godot-haskell
   - gofer-prelude
-  - gogol-core
+  - gogol-admin-emailmigration
+  - gogol-affiliates
+  - gogol-autoscaler
+  - gogol-bigtableadmin
+  - gogol-cloudmonitoring
+  - gogol-freebasesearch
+  - gogol-latencytest
+  - gogol-maps-coordinate
+  - gogol-maps-engine
+  - gogol-photoslibrary
+  - gogol-resourceviews
+  - gogol-servicemanagement
+  - gogol-taskqueue
+  - gogol-useraccounts
   - gooey
   - google-cloud
   - GoogleCodeJam
···
   - shorten-strings
   - short-vec
   - show-prettyprint
+  - Shpadoinkle-backend-pardiff
   - Shpadoinkle-backend-snabbdom
   - Shpadoinkle-isreal
   - Shpadoinkle-streaming
+  - Shpadoinkle-template
+  - Shpadoinkle-widgets
   - shwifty
   - sifflet
   - sifflet-lib

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

···
   - hiedb == 0.4.0.*
   # 2021-10-13: weeder 2.3.0 require GHC == 9.0.*; remove pin when GHC version changes
   - weeder < 2.3.0
+  # 2021-10-10: taskwarrior 0.4 requires aeson > 2.0.1.0
+  - taskwarrior < 0.4.0.0
+  # 2021-10-19: autoapply 0.4.1.1 requires th-desugar 1.12
+  - autoapply < 0.4.1.1
+  # 2021-10-22: 1.8 breaks shake-bench
+  - SVGFonts < 1.8
 
 extra-packages:
   - base16-bytestring < 1               # required for cabal-install etc.
···
     - spago
     - termonad
   dalpd:
+    - ghc-vis
     - svgcairo
   domenkozar:
     - cachix

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

···
  - Shellac-haskeline
  - Shellac-readline
  - ShortestPathProblems
+ - Shpadoinkle-developer-tools
  - Shpadoinkle-disembodied
  - Shpadoinkle-examples
  - Shpadoinkle-router
···
  - findhttp
  - finite-table
  - firstify
+ - fishfood
  - fix-parser-simple
  - fixed-point-vector
  - fixed-point-vector-space
···
  - goal-probability
  - goal-simulation
  - goat
- - gogol
- - gogol-abusiveexperiencereport
- - gogol-acceleratedmobilepageurl
- - gogol-accessapproval
- - gogol-accesscontextmanager
- - gogol-adexchange-buyer
- - gogol-adexchange-seller
- - gogol-adexchangebuyer2
- - gogol-adexperiencereport
- - gogol-admin-datatransfer
- - gogol-admin-directory
- - gogol-admin-emailmigration
- - gogol-admin-reports
- - gogol-adsense
- - gogol-adsense-host
- - gogol-affiliates
- - gogol-alertcenter
- - gogol-analytics
- - gogol-analyticsreporting
- - gogol-android-enterprise
- - gogol-android-publisher
- - gogol-androiddeviceprovisioning
- - gogol-androidmanagement
- - gogol-appengine
- - gogol-apps-activity
- - gogol-apps-calendar
- - gogol-apps-licensing
- - gogol-apps-reseller
- - gogol-apps-tasks
- - gogol-appstate
- - gogol-autoscaler
- - gogol-bigquery
- - gogol-bigquerydatatransfer
- - gogol-bigtableadmin
- - gogol-billing
- - gogol-binaryauthorization
- - gogol-blogger
- - gogol-books
- - gogol-chat
- - gogol-civicinfo
- - gogol-classroom
- - gogol-cloudasset
- - gogol-clouderrorreporting
- - gogol-cloudfunctions
- - gogol-cloudidentity
- - gogol-cloudiot
- - gogol-cloudkms
- - gogol-cloudmonitoring
- - gogol-cloudprivatecatalog
- - gogol-cloudprivatecatalogproducer
- - gogol-cloudprofiler
- - gogol-cloudscheduler
- - gogol-cloudsearch
- - gogol-cloudshell
- - gogol-cloudtasks
- - gogol-cloudtrace
- - gogol-commentanalyzer
- - gogol-composer
- - gogol-compute
- - gogol-consumersurveys
- - gogol-container
- - gogol-containeranalysis
- - gogol-containerbuilder
- - gogol-customsearch
- - gogol-dataflow
- - gogol-datafusion
- - gogol-dataproc
- - gogol-datastore
- - gogol-debugger
- - gogol-deploymentmanager
- - gogol-dfareporting
- - gogol-dialogflow
- - gogol-digitalassetlinks
- - gogol-discovery
- - gogol-dlp
- - gogol-dns
- - gogol-docs
- - gogol-doubleclick-bids
- - gogol-doubleclick-search
- - gogol-drive
- - gogol-driveactivity
- - gogol-factchecktools
- - gogol-file
- - gogol-firebase-dynamiclinks
- - gogol-firebase-rules
- - gogol-firebasehosting
- - gogol-firebaseremoteconfig
- - gogol-firestore
- - gogol-fitness
- - gogol-fonts
- - gogol-freebasesearch
- - gogol-fusiontables
- - gogol-games
- - gogol-games-configuration
- - gogol-games-management
- - gogol-genomics
- - gogol-gmail
- - gogol-groups-migration
- - gogol-groups-settings
- - gogol-healthcare
- - gogol-iam
- - gogol-iamcredentials
- - gogol-iap
- - gogol-identity-toolkit
- - gogol-indexing
- - gogol-jobs
- - gogol-kgsearch
- - gogol-language
- - gogol-latencytest
- - gogol-libraryagent
- - gogol-logging
- - gogol-manufacturers
- - gogol-maps-coordinate
- - gogol-maps-engine
- - gogol-mirror
- - gogol-ml
- - gogol-monitoring
- - gogol-oauth2
- - gogol-oslogin
- - gogol-pagespeed
- - gogol-partners
- - gogol-people
- - gogol-photoslibrary
- - gogol-play-moviespartner
- - gogol-playcustomapp
- - gogol-plus
- - gogol-plus-domains
- - gogol-poly
- - gogol-prediction
- - gogol-proximitybeacon
- - gogol-pubsub
- - gogol-qpxexpress
- - gogol-redis
- - gogol-remotebuildexecution
- - gogol-replicapool
- - gogol-replicapool-updater
- - gogol-resourcemanager
- - gogol-resourceviews
- - gogol-run
- - gogol-runtimeconfig
- - gogol-safebrowsing
- - gogol-script
- - gogol-searchconsole
- - gogol-securitycenter
- - gogol-servicebroker
- - gogol-serviceconsumermanagement
- - gogol-servicecontrol
- - gogol-servicemanagement
- - gogol-servicenetworking
- - gogol-serviceusage
- - gogol-serviceuser
- - gogol-sheets
- - gogol-shopping-content
- - gogol-siteverification
- - gogol-slides
- - gogol-sourcerepo
- - gogol-spanner
- - gogol-spectrum
- - gogol-speech
- - gogol-sqladmin
- - gogol-storage
- - gogol-storage-transfer
- - gogol-streetviewpublish
- - gogol-surveys
- - gogol-tagmanager
- - gogol-taskqueue
- - gogol-testing
- - gogol-texttospeech
- - gogol-toolresults
- - gogol-tpu
- - gogol-tracing
- - gogol-translate
- - gogol-urlshortener
- - gogol-useraccounts
- - gogol-vault
- - gogol-videointelligence
- - gogol-vision
- - gogol-webmaster-tools
- - gogol-websecurityscanner
- - gogol-youtube
- - gogol-youtube-analytics
- - gogol-youtube-reporting
  - google-drive
  - google-mail-filters
  - google-maps-geocoding
···
  - sql-simple-postgresql
  - sql-simple-sqlite
  - sqlite-simple-typed
+ - squeeze
  - sr-extra
  - sscgi
  - sshd-lint

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

···
        license = lib.licenses.bsd3;
      }) {};
 
+  "SVGFonts_1_8" = callPackage
+    ({ mkDerivation, attoparsec, base, blaze-markup, blaze-svg
+     , bytestring, cereal, cereal-vector, containers, data-default-class
+     , diagrams-core, diagrams-lib, directory, parsec, split, text
+     , vector, xml
+     }:
+     mkDerivation {
+       pname = "SVGFonts";
+       version = "1.8";
+       sha256 = "1aqwckrm0vy7y0i8ymq0kvshwwwdrvy13x9jhpxk466mcj19gg2g";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         attoparsec base blaze-markup blaze-svg bytestring cereal
+         cereal-vector containers data-default-class diagrams-core
+         diagrams-lib directory parsec split text vector xml
+       ];
+       description = "Fonts from the SVG-Font format";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "SVGPath" = callPackage
     ({ mkDerivation, base, parsec }:
      mkDerivation {
···
        ];
        description = "A Virtual Dom in pure Haskell, based on Html as an Alignable Functor";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "Shpadoinkle-backend-snabbdom" = callPackage
···
        ];
        description = "Chrome extension to aide in development";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Shpadoinkle-disembodied" = callPackage
···
        ];
        description = "Read standard file formats into Shpadoinkle with Template Haskell";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "Shpadoinkle-widgets" = callPackage
···
        ];
        description = "A collection of common reusable types and components";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "Shrub" = callPackage
···
      }:
      mkDerivation {
        pname = "ansi-terminal-game";
-       version = "1.2.1.0";
-       sha256 = "1gzqf0dby0w25nbz6lzlb4b7jgxydv09wqfcvbcfjwn0wg76wfvc";
+       version = "1.3.0.0";
+       sha256 = "08s49nwdj8wlydpbrzxsbz451gfa97n2kvvdv4wfbhwc4gspi9pa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "argo" = callPackage
-    ({ mkDerivation, array, base, bytestring, deepseq, tasty
-     , tasty-bench, tasty-hunit, tasty-quickcheck, text
+    ({ mkDerivation, array, base, bytestring, containers, deepseq
+     , tasty, tasty-bench, tasty-hunit, tasty-quickcheck
+     , template-haskell, text
      }:
      mkDerivation {
        pname = "argo";
-       version = "0.2021.10.13";
-       sha256 = "1jlw1v0kzcapc0ziax15hxgvb86q7cby7dpsqlrygw0y72w05w9q";
+       version = "0.2021.10.17";
+       sha256 = "0chzjpdz2x7nkqhphxj2x9knhdjm9dz2880s6f04p6w4w849pm33";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ array base bytestring deepseq text ];
-       executableHaskellDepends = [ array base bytestring deepseq text ];
+       libraryHaskellDepends = [
+         array base bytestring containers deepseq template-haskell text
+       ];
+       executableHaskellDepends = [
+         array base bytestring containers deepseq template-haskell text
+       ];
        testHaskellDepends = [
-         array base bytestring deepseq tasty tasty-hunit tasty-quickcheck
-         text
+         array base bytestring containers deepseq tasty tasty-hunit
+         tasty-quickcheck template-haskell text
        ];
        benchmarkHaskellDepends = [
-         array base bytestring deepseq tasty-bench text
+         array base bytestring containers deepseq tasty-bench
+         template-haskell text
        ];
        description = "Parse and render JSON";
        license = lib.licenses.mit;
···
        maintainers = with lib.maintainers; [ expipiplus1 ];
      }) {};
 
+  "autoapply_0_4_1_1" = callPackage
+    ({ mkDerivation, base, Cabal, cabal-doctest, doctest, logict, mtl
+     , template-haskell, th-desugar, transformers, unification-fd
+     }:
+     mkDerivation {
+       pname = "autoapply";
+       version = "0.4.1.1";
+       sha256 = "1gpc08j5sq51kz1ysjnm50h89zd6g9r9grbc49jrrbnqirnnl6fl";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         base logict mtl template-haskell th-desugar transformers
+         unification-fd
+       ];
+       testHaskellDepends = [ base doctest ];
+       description = "Template Haskell to automatically pass values to functions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ expipiplus1 ];
+     }) {};
+
   "autoexporter" = callPackage
     ({ mkDerivation, base, Cabal, directory, filepath }:
      mkDerivation {
···
        pname = "base-compat";
        version = "0.11.2";
        sha256 = "1nyvkaij4m01jndw72xl8931czz1xp6jpnynpajabys2ahabb9jk";
+       revision = "1";
+       editedCabalFile = "0h6vr19vr5bhm69w8rvswbvd4xgazggkcq8vz934x69www2cpgri";
        libraryHaskellDepends = [ base unix ];
        description = "A compatibility layer for base";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "bugsnag-hs_0_2_0_5" = callPackage
+  "bugsnag-hs_0_2_0_6" = callPackage
     ({ mkDerivation, aeson, base, bytestring, hedgehog, http-client
      , text, time, unordered-containers
      }:
      mkDerivation {
        pname = "bugsnag-hs";
-       version = "0.2.0.5";
-       sha256 = "1gm38w8vjgxmn2a9a7xr364pcv7vsvd3brf90hwbwh7y88q6jdn2";
+       version = "0.2.0.6";
+       sha256 = "0kq2mxsl6rm95v551vwjcim0sfk2lhc2n95f28pmglpp5qxc1q7j";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring http-client text time unordered-containers
···
        libraryHaskellDepends = [ base bytestring ];
        description = "Parse and produce literals efficiently from strict or lazy bytestrings";
        license = lib.licenses.bsd2;
+     }) {};
+
+  "bytestring-lexing_0_5_0_7" = callPackage
+    ({ mkDerivation, base, bytestring, tasty, tasty-quickcheck
+     , tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "bytestring-lexing";
+       version = "0.5.0.7";
+       sha256 = "1p7i2haix4m11an3djaq65cnd293hzwqy4cd2i8jxzcl248pk6iy";
+       libraryHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [
+         base bytestring tasty tasty-quickcheck tasty-smallcheck
+       ];
+       description = "Efficiently parse and produce common integral and fractional numbers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bytestring-mmap" = callPackage
···
     ({ mkDerivation, base, binary, bytestring }:
      mkDerivation {
        pname = "bytestring-trie";
-       version = "0.2.5.0";
-       sha256 = "1jpynpyarikxhlc4ifdswvkj0ph9fd5d0vcxhjv0lrv0zwqvv488";
-       revision = "2";
-       editedCabalFile = "0z2d6k7w2bzjdjvhk5aa5a8j6x5m84xj03rgb4jb70psifmzkg9f";
+       version = "0.2.5.2";
+       sha256 = "1sxym7phj61cwpdp6ajh6jrnm9n48n0rzkm06ynip609d9n5zq3w";
        libraryHaskellDepends = [ base binary bytestring ];
        description = "An efficient finite map from (byte)strings to values";
        license = lib.licenses.bsd3;
···
        pname = "constraints";
        version = "0.13";
        sha256 = "143558jykvya7y8134dx30g6nh27q5s61nbq369p69igd1aayncj";
+       revision = "1";
+       editedCabalFile = "1bzhyaxgf4fqg7gakhqgr054mnl2ghc6b1fcb9hw171zj89hsc9w";
        libraryHaskellDepends = [
          base binary deepseq ghc-prim hashable mtl transformers
          transformers-compat type-equality
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "data-or_1_0_0_7" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "data-or";
+       version = "1.0.0.7";
+       sha256 = "1n8ym5skpyd15akra1vj97z2h3bq62fh1966yz1i8qds5xq96a4x";
+       libraryHaskellDepends = [ base ];
+       description = "A data type for non-exclusive disjunction";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "data-ordlist" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "discord-haskell";
-       version = "1.8.8";
-       sha256 = "0fvj9m59gsdicl061xlkqq8hrwsksyrysjdh5ijbv8gaql99k17v";
+       version = "1.8.9";
+       sha256 = "0qgbiqn05bn52fsihvz385smgvbkagc435qgmlm74clqfg7flwi4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        executableHaskellDepends = [ aeson base filepath text ];
        description = "Visualise an eventlog";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "eventloop" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "exact-combinatorics_0_2_0_10" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "exact-combinatorics";
+       version = "0.2.0.10";
+       sha256 = "08xdn2dl9r1zkphm9ja3lp4qin9cn889q184lsmk432icbvw5r2h";
+       libraryHaskellDepends = [ base ];
+       description = "Efficient exact computation of combinatoric functions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "exact-cover" = callPackage
     ({ mkDerivation, base, containers, tasty, tasty-hunit }:
      mkDerivation {
···
        ];
        description = "Rational arithmetic in an irrational world";
        license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "facts" = callPackage
···
        broken = true;
      }) {};
 
+  "firestore" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring
+     , generic-random, gogol, gogol-firestore, http-types, lens
+     , lens-aeson, QuickCheck, quickcheck-instances, resourcet, text
+     , time, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "firestore";
+       version = "0.1.0.0";
+       sha256 = "0xzd0w8px22vq8fs7nyri1l8inb8nj832mfwgphcqqrpapbq8h17";
+       libraryHaskellDepends = [
+         aeson base bytestring gogol gogol-firestore http-types lens
+         lens-aeson resourcet text time unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty base bytestring generic-random gogol
+         gogol-firestore http-types lens lens-aeson QuickCheck
+         quickcheck-instances resourcet text time unordered-containers
+         vector
+       ];
+       description = "Wrapper for Google Firestore/Datastore API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "first-and-last" = callPackage
     ({ mkDerivation, base, doctest }:
      mkDerivation {
···
        ];
        description = "Calculates file-size frequency-distribution";
        license = "GPL";
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fit" = callPackage
···
        pname = "flat";
        version = "0.4.4";
        sha256 = "02i4nzzkmm11sp312k2d3d3g0gm2gzhh3ibczxxscl986svam7p3";
+       revision = "1";
+       editedCabalFile = "1f9vlfnkr20nh5nayj18wvwh061w0byrd88j01k9gnrmb7qykpf6";
        libraryHaskellDepends = [
          array base bytestring containers deepseq dlist ghc-prim hashable
          mono-traversable pretty primitive semigroups text
···
      }:
      mkDerivation {
        pname = "flatparse";
-       version = "0.3.0.0";
-       sha256 = "0x6q1dwk9zr9s7rx3knm127pjnkpcqmihdzajfcmvi0ayviq984i";
+       version = "0.3.1.0";
+       sha256 = "119qqqzp3aaljxgw0fdvqi2mhpykff33rmm8b5v7y3mllz707mf3";
        libraryHaskellDepends = [
          base bytestring containers integer-gmp template-haskell
        ];
···
        pname = "fmr";
        version = "0.1";
        sha256 = "1hwi4f027pv1sy6pmanc0488xdy398iv50yapivyk2l9kipfnq3q";
+       revision = "1";
+       editedCabalFile = "0xg1q3bjfg9l6xv8cixzydsypjy7nsbirsb14vfpnp42m7ml5klq";
        libraryHaskellDepends = [ base ];
        description = "Fake monadic records library";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "freckle-app";
-       version = "1.0.0.3";
-       sha256 = "13iw0fj3n409mjbc6kkxcy1jx2zg8dwd55qp150qrkbmmjvrw54q";
+       version = "1.0.0.4";
+       sha256 = "0r3sfy7i796qjk3h7kigdj8c1gyrbzbwan7lb41r75h8bqx96p70";
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring case-insensitive conduit
          data-default datadog doctest errors exceptions fast-logger filepath
···
        pname = "futhark";
        version = "0.20.4";
        sha256 = "0yjm0s9risrc0aj1si8i403k6b1znr8szff1f8ksb5cr9j7nn7gn";
+       revision = "1";
+       editedCabalFile = "0kx2p48b56icbd1bf6y6qbqx7sb7r8d2lcjxb60khiz7ff8kqjw8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "ghc-datasize" = callPackage
-    ({ mkDerivation, base, deepseq, ghc-lib-parser-ex, ghc-prim }:
+    ({ mkDerivation, base, deepseq, ghc-prim }:
      mkDerivation {
        pname = "ghc-datasize";
-       version = "0.2.3";
-       sha256 = "1sbzharb72ngbq10mqvia4yb71mkhk5s5n1xd8nm11xpvqy4q28k";
-       libraryHaskellDepends = [
-         base deepseq ghc-lib-parser-ex ghc-prim
-       ];
+       version = "0.2.5";
+       sha256 = "1n8pz93lga1mizla91fwz16gd0831wjqskqbk0qr4m585zpzhh4d";
+       libraryHaskellDepends = [ base deepseq ghc-prim ];
        description = "Determine the size of data structures in GHC's memory";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        ];
        description = "Live visualization of data structures in GHCi";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       maintainers = with lib.maintainers; [ dalpd ];
      }) {};
 
   "ghcflags" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "github-release_1_3_8" = callPackage
+    ({ mkDerivation, aeson, base, burrito, bytestring, http-client
+     , http-client-tls, http-types, mime-types, optparse-generic, text
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "github-release";
+       version = "1.3.8";
+       sha256 = "1p8pmingim3vicmrzfs49b3xv71ihlvdd6cppbpa91vi3s2dh04v";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base burrito bytestring http-client http-client-tls
+         http-types mime-types optparse-generic text unordered-containers
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Upload files to GitHub releases";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "github-rest" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, bytestring, http-client
      , http-client-tls, http-types, jwt, mtl, scientific, tasty
···
        ];
        description = "Comprehensive Google Services SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-abusiveexperiencereport" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Abusive Experience Report SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-acceleratedmobilepageurl" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Accelerated Mobile Pages (AMP) URL SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-accessapproval" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Access Approval SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-accesscontextmanager" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Access Context Manager SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-adexchange-buyer" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Ad Exchange Buyer SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-adexchange-seller" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Ad Exchange Seller SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-adexchangebuyer2" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Ad Exchange Buyer API II SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-adexperiencereport" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Ad Experience Report SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-admin-datatransfer" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Admin Data Transfer SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-admin-directory" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Admin Directory SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-admin-emailmigration" = callPackage
···
        description = "Google Email Migration API v2 SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-admin-reports" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Admin Reports SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-adsense" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google AdSense Management SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-adsense-host" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google AdSense Host SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-affiliates" = callPackage
···
        description = "Google Affiliate Network SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-alertcenter" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google G Suite Alert Center SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-analytics" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Analytics SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-analyticsreporting" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Analytics Reporting SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-android-enterprise" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Play EMM SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-android-publisher" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Play Developer SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-androiddeviceprovisioning" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Android Device Provisioning Partner SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-androidmanagement" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Android Management SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-appengine" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google App Engine Admin SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-apps-activity" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Drive Activity SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-apps-calendar" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Calendar SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-apps-licensing" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Enterprise License Manager SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-apps-reseller" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Enterprise Apps Reseller SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-apps-tasks" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Tasks SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-appstate" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google App State SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-autoscaler" = callPackage
···
        description = "Google Compute Engine Autoscaler SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-bigquery" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google BigQuery SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-bigquerydatatransfer" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google BigQuery Data Transfer SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-bigtableadmin" = callPackage
···
        description = "Google Cloud Bigtable Admin SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-billing" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Billing SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-binaryauthorization" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Binary Authorization SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-blogger" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Blogger SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-books" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Books SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-chat" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Hangouts Chat SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-civicinfo" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Civic Information SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-classroom" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Classroom SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudasset" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Asset SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-clouderrorreporting" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Stackdriver Error Reporting SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudfunctions" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Functions SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudidentity" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Identity SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudiot" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud IoT SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudkms" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Key Management Service (KMS) SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudmonitoring" = callPackage
···
        description = "Google Cloud Monitoring SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-cloudprivatecatalog" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Private Catalog SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudprivatecatalogproducer" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Private Catalog Producer SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudprofiler" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Stackdriver Profiler SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudscheduler" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Scheduler SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudsearch" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Search SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudshell" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Shell SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudtasks" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Tasks SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-cloudtrace" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Stackdriver Trace SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-commentanalyzer" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Perspective Comment Analyzer SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-composer" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Composer SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-compute" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Compute Engine SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-consumersurveys" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Consumer Surveys SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-container" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Kubernetes Engine SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-containeranalysis" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Container Analysis SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-containerbuilder" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Build SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-core" = callPackage
···
        testHaskellDepends = [ base tasty ];
        description = "Core data types and functionality for Gogol libraries";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "gogol-customsearch" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google CustomSearch SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-dataflow" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Dataflow SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-datafusion" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Data Fusion SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-dataproc" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Dataproc SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-datastore" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Datastore SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-debugger" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Stackdriver Debugger SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-deploymentmanager" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Deployment Manager SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-dfareporting" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google DCM/DFA Reporting And Trafficking SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-dialogflow" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Dialogflow SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-digitalassetlinks" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Digital Asset Links SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-discovery" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google API Discovery Service SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-dlp" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Data Loss Prevention (DLP) SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-dns" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud DNS SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-docs" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Docs SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-doubleclick-bids" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google DoubleClick Bid Manager SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-doubleclick-search" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google DoubleClick Search SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-drive" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Drive SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-driveactivity" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Drive Activity SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-factchecktools" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Fact Check Tools SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-file" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Filestore SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-firebase-dynamiclinks" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Firebase Dynamic Links SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-firebase-rules" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Firebase Rules SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-firebasehosting" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Firebase Hosting SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-firebaseremoteconfig" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Firebase Remote Config SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-firestore" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Firestore SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-fitness" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Fitness SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-fonts" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Fonts Developer SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-freebasesearch" = callPackage
···
        description = "Google Freebase Search SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-fusiontables" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Fusion Tables SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-games" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Play Game Services SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-games-configuration" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Play Game Services Publishing SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-games-management" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Play Game Services Management SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-genomics" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Genomics SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-gmail" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Gmail SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-groups-migration" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Groups Migration SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-groups-settings" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Groups Settings SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-healthcare" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Healthcare SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-iam" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Identity and Access Management (IAM) SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-iamcredentials" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google IAM Service Account Credentials SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-iap" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Identity-Aware Proxy SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-identity-toolkit" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Identity Toolkit SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-indexing" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Indexing SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-jobs" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Talent Solution SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-kgsearch" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Knowledge Graph Search SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-language" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Natural Language SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-latencytest" = callPackage
···
        description = "Google Cloud Network Performance Monitoring SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-libraryagent" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Library Agent SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-logging" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Stackdriver Logging SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-manufacturers" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Manufacturer Center SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-maps-coordinate" = callPackage
···
        description = "Google Maps Coordinate SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-maps-engine" = callPackage
···
        description = "Google Maps Engine SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-mirror" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Mirror SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-ml" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Machine Learning Engine SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-monitoring" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Stackdriver Monitoring SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-oauth2" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google OAuth2 SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-oslogin" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud OS Login SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-pagespeed" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google PageSpeed Insights SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-partners" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Partners SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-people" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google People SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-photoslibrary" = callPackage
···
        description = "Google Photos Library SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-play-moviespartner" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Play Movies Partner SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-playcustomapp" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Play Custom App Publishing SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-plus" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google + SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-plus-domains" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google + Domains SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-poly" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Poly SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-prediction" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Prediction SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-proximitybeacon" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Proximity Beacon SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-pubsub" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Pub/Sub SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-qpxexpress" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google QPX Express SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-redis" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Memorystore for Redis SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-remotebuildexecution" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Remote Build Execution SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-replicapool" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Replica Pool SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-replicapool-updater" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Compute Engine Instance Group Updater SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-resourcemanager" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Resource Manager SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-resourceviews" = callPackage
···
        description = "Google Compute Engine Instance Groups SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-run" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Run SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-runtimeconfig" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Runtime Configuration SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-safebrowsing" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Safe Browsing SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-script" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Apps Script SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-searchconsole" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Search Console URL Testing Tools SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-securitycenter" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Security Command Center SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-servicebroker" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Service Broker SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-serviceconsumermanagement" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Service Consumer Management SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-servicecontrol" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Service Control SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-servicemanagement" = callPackage
···
        description = "Google Service Management SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-servicenetworking" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Service Networking SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-serviceusage" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Service Usage SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-serviceuser" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Service User SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-sheets" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Sheets SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-shopping-content" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Content API for Shopping SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-siteverification" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Site Verification SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-slides" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Slides SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-sourcerepo" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Source Repositories SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-spanner" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Spanner SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-spectrum" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Spectrum Database SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-speech" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Speech-to-Text SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-sqladmin" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud SQL Admin SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-storage" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Storage JSON SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-storage-transfer" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Storage Transfer SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-streetviewpublish" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Street View Publish SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-surveys" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Surveys SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-tagmanager" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Tag Manager SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-taskqueue" = callPackage
···
        description = "Google TaskQueue SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-testing" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Testing SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-texttospeech" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Text-to-Speech SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-toolresults" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Tool Results SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-tpu" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud TPU SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-tracing" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Tracing SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-translate" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Translation SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-urlshortener" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google URL Shortener SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-useraccounts" = callPackage
···
        description = "Google Cloud User Accounts SDK";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-vault" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google G Suite Vault SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-videointelligence" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Video Intelligence SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-vision" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Cloud Vision SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-webmaster-tools" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Search Console SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-websecurityscanner" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google Web Security Scanner SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-youtube" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google YouTube Data SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-youtube-analytics" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google YouTube Analytics SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gogol-youtube-reporting" = callPackage
···
        libraryHaskellDepends = [ base gogol-core ];
        description = "Google YouTube Reporting SDK";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "goldplate" = callPackage
···
      }:
      mkDerivation {
        sha256 = "0ibbf8nq81b533902wkh0ags4a1jydm5jq0gn6jp1pg465q6qn7j";
-       version = "0.2.1";
-       sha256 = "0ibbf8nq81b533902wkh0ags4a1jydm5jq0gn6jp1pg465q6qn7j";
+       version = "0.2.2";
+       sha256 = "0xpyw9q684ms5aaq9rpfn9m2fxgvprmci8kvz81pj0qjsxhkzfhh";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hvega_0_12_0_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
+     , filepath, tasty, tasty-golden, text, unordered-containers
+     }:
+     mkDerivation {
+       pname = "hvega";
+       version = "0.12.0.0";
+       sha256 = "1zb79dbnznp1y08a497kgc423c7zmppz0qkfb04bnmffcp1p1ymn";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ aeson base text unordered-containers ];
+       testHaskellDepends = [
+         aeson aeson-pretty base bytestring containers filepath tasty
+         tasty-golden text unordered-containers
+       ];
+       description = "Create Vega-Lite visualizations (version 4) in Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hvega-theme" = callPackage
     ({ mkDerivation, base, hvega, text }:
      mkDerivation {
···
     ({ mkDerivation, aeson, base, hvega, ihaskell, text }:
      mkDerivation {
        pname = "ihaskell-hvega";
-       version = "0.3.2.0";
-       sha256 = "0k7h33cqj58dv4hrsdjgnbykh036mrvbw6cbr98xlkdq5062pnzp";
+       version = "0.4.0.0";
+       sha256 = "0sdgrlirnjb1bg6l5a6k3y084q3jddl08h032m0smaalvzcyl21b";
        libraryHaskellDepends = [ aeson base hvega ihaskell text ];
        description = "IHaskell display instance for hvega types";
        license = lib.licenses.bsd3;
···
        testHaskellDepends = [ base bytestring filepath hspec ];
        description = "JSON Feed";
        license = lib.licenses.mit;
+     }) {};
+
+  "json-feed_1_0_14" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, filepath, hspec
+     , mime-types, network-uri, tagsoup, text, time
+     }:
+     mkDerivation {
+       pname = "json-feed";
+       version = "1.0.14";
+       sha256 = "1jfyx1n3yxb8shi2s6an0glccniyp2hwyas38xpf6a9q6nzjagys";
+       libraryHaskellDepends = [
+         aeson base bytestring mime-types network-uri tagsoup text time
+       ];
+       testHaskellDepends = [ base bytestring filepath hspec ];
+       description = "JSON Feed";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "json-fu" = callPackage
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "list-extras";
-       version = "0.4.1.4";
-       sha256 = "15vjk6y3zwiffm1x8wlzv6203ykzm2phalqlq4zhmhcj2wd70viw";
+       version = "0.4.1.6";
+       sha256 = "0h5abhm84vhk5pfd6rrimgrb5l2bs2w5a7gpkg0rvlacbv4di4rz";
        libraryHaskellDepends = [ base ];
        description = "Common not-so-common functions for lists";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, enumset, LLVM }:
      mkDerivation {
        pname = "llvm-ffi";
-       version = "9.1.0.1";
-       sha256 = "19bj8gkzmzg3khnj1pnksc789p1hls0ji48kvwp72zbhhzgpr75d";
-       revision = "1";
-       editedCabalFile = "0iq9csqrbzrhvpzgz8nbs9k390sh3440002ipcicjlqkm4ssi330";
+       version = "10.0";
+       sha256 = "0damvra488px3gskqxyyb0rysyh6sza27q190c01i1icisalc8dh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base enumset ];
···
 
   "llvm-pkg-config" = callPackage
     ({ mkDerivation, base, Cabal, explicit-exception, process
-     , transformers, utility-ht
+     , shell-utility, transformers, utility-ht
      }:
      mkDerivation {
        pname = "llvm-pkg-config";
-       version = "0.0.1";
-       sha256 = "1ynxkdaanw3nxpsgfcjg6wsz6jgxszp239xhssyzasz59qhw64rr";
+       version = "0.0.2";
+       sha256 = "1p4ww8ylhr4ag1dfz4sffkg2qsyjj4zxccda3nr50k3c26pmmdz1";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base Cabal explicit-exception process transformers utility-ht
+         base Cabal explicit-exception process shell-utility transformers
+         utility-ht
        ];
        description = "Generate Pkg-Config configuration file for LLVM";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "llvm-tf";
-       version = "9.2";
-       sha256 = "1p4r9m1svp6k235r0azx6dkpdarakgy3420z3kk06bdiy1m2jk1s";
-       revision = "1";
-       editedCabalFile = "0maav3vis08vdvp0zwclyjznf2k4r8qi7szpwxhkya0xa87fh96d";
+       version = "9.2.0.1";
+       sha256 = "0icn48k9g1gy335rmwb06jgffywjfyf3as7ihm0006l07nvyf63q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        libraryHaskellDepends = [ array base ];
        description = "Log-domain floating point numbers";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "logfloat_0_13_4" = callPackage
+    ({ mkDerivation, array, base }:
+     mkDerivation {
+       pname = "logfloat";
+       version = "0.13.4";
+       sha256 = "0kbx7p3lfbvqfcqpwfspm82x3z404sa85k586jwlkhyh7rxv1fh3";
+       libraryHaskellDepends = [ array base ];
+       description = "Log-domain floating point numbers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "logfmt" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lucid_2_10_0" = callPackage
+    ({ mkDerivation, base, bifunctors, blaze-builder, bytestring
+     , containers, criterion, deepseq, hashable, hspec, HUnit, mmorph
+     , mtl, parsec, text, transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "lucid";
+       version = "2.10.0";
+       sha256 = "1xzrb31n1kx6ym8za32ggy0cxmm2pcv9vm5czzsip5va6p5411yg";
+       libraryHaskellDepends = [
+         base blaze-builder bytestring containers hashable mmorph mtl text
+         transformers unordered-containers
+       ];
+       testHaskellDepends = [
+         base bifunctors hspec HUnit mtl parsec text
+       ];
+       benchmarkHaskellDepends = [
+         base blaze-builder bytestring criterion deepseq text transformers
+       ];
+       description = "Clear to write, read and edit DSL for HTML";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lucid-cdn" = callPackage
     ({ mkDerivation, base, lucid }:
      mkDerivation {
···
        description = "Matlab bindings and interface";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
-     }) {eng = null; mat = null; inherit (pkgs) mx;};
+     }) {eng = null; mat = null; mx = null;};
 
   "matplotlib" = callPackage
     ({ mkDerivation, ad, aeson, base, bytestring, containers, deepseq
···
        pname = "nanovg";
        version = "0.8.0.0";
        sha256 = "1il4305wv7f53225jv5s04nf7gf5rw6cfxm8j3v1di2xvhdingz5";
+       revision = "1";
+       editedCabalFile = "0m69iqs8jaqh1gq1vfp92j2adf05v0isakl3ijxf7akxs5j2i3da";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring containers text vector ];
···
      }:
      mkDerivation {
        pname = "nri-kafka";
-       version = "0.1.0.1";
-       sha256 = "0sybcf7lx0gqhi79h6d1rqx0ckyz38m86h87imrh4grgbikxaic5";
+       version = "0.1.0.2";
+       sha256 = "0bqpfcivp2hx5s2dmx2jwndia4pwfppslzr3krqwmph1qy3h2v9i";
        libraryHaskellDepends = [
          aeson async base bytestring conduit containers hw-kafka-client
          nri-env-parser nri-observability nri-prelude safe-exceptions stm
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "nri-observability_0_1_1_2" = callPackage
+  "nri-observability_0_1_1_3" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, async, base, bugsnag-hs
      , bytestring, conduit, directory, hostname, http-client
      , http-client-tls, nri-env-parser, nri-prelude, random
···
      }:
      mkDerivation {
        pname = "nri-observability";
-       version = "0.1.1.2";
-       sha256 = "0n4ap88ll5q86addjgfv8pf86zbnw1ic6wh7wc929fn4ygc6r2x5";
+       version = "0.1.1.3";
+       sha256 = "0brjddl4ff8881ld41sp7ix3skxgj10jign4xx8l3ad89f91621b";
        libraryHaskellDepends = [
          aeson aeson-pretty async base bugsnag-hs bytestring conduit
          directory hostname http-client http-client-tls nri-env-parser
···
      }:
      mkDerivation {
        pname = "nri-postgresql";
-       version = "0.1.0.2";
-       sha256 = "0rm76z57zvvsswd0dyqmq7m1mrvamiff5kawkcwy4k4xkn4yl3py";
+       version = "0.1.0.3";
+       sha256 = "0v07b6yq2i2pnfmiaks2vp3yj2ncfr9c3f2fx9sq6hr9z56q8hqd";
        libraryHaskellDepends = [
          attoparsec base bytestring filepath network nri-env-parser
          nri-observability nri-prelude postgresql-typed resource-pool
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "nri-prelude_0_6_0_4" = callPackage
+  "nri-prelude_0_6_0_5" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, async, auto-update, base
      , bytestring, containers, directory, exceptions, filepath, ghc
      , hedgehog, junit-xml, pretty-diff, pretty-show, safe-coloured-text
···
      }:
      mkDerivation {
        pname = "nri-prelude";
-       version = "0.6.0.4";
-       sha256 = "0r2jgjrbjbkkvsk8ypg0d7r840qkadwinq0qyhng9bkjqrsrn78c";
+       version = "0.6.0.5";
+       sha256 = "0qam6bamjp92mky193iddpq3v7knsxx4kcyc8fw3a8nkbrx6gigh";
        libraryHaskellDepends = [
          aeson aeson-pretty async auto-update base bytestring containers
          directory exceptions filepath ghc hedgehog junit-xml pretty-diff
···
        broken = true;
      }) {};
 
+  "owoify-hs" = callPackage
+    ({ mkDerivation, base, HUnit, random, regex, regex-with-pcre, text
+     }:
+     mkDerivation {
+       pname = "owoify-hs";
+       version = "1.0.0.1";
+       sha256 = "0h7z4hsf5x9qi892sd9jx6r9vcnaskbpxhpq64vmvd2805cznyr1";
+       libraryHaskellDepends = [ base random regex regex-with-pcre text ];
+       testHaskellDepends = [
+         base HUnit random regex regex-with-pcre text
+       ];
+       description = "Turn any English text into nonsensical babyspeaks";
+       license = lib.licenses.mit;
+     }) {};
+
   "pack" = callPackage
     ({ mkDerivation, array, base, bytestring, lens, transformers
      , vector
···
        pname = "persistent-typed-db";
        version = "0.1.0.4";
        sha256 = "1dd5kig6zkiq5qkqv63icz9z8mn0b56b06w6z980hi7a2bmp6pk8";
+       revision = "1";
+       editedCabalFile = "07irkdph44vw5g8ixrpw3rlmx13nsxbbcznz2k2jiyw5i3nd1b94";
        libraryHaskellDepends = [
          aeson base bytestring conduit http-api-data monad-logger
          path-pieces persistent resource-pool resourcet template-haskell
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-array";
-       version = "0.12.1.0";
-       sha256 = "0wp5gpshmq5kr39glvfmc0b5jg8p1i146svjxh6flgkfn7yyr6rf";
+       version = "0.13.0.0";
+       sha256 = "02f4hvzva39fjhbi4nhxf9n7fm5dvl35g3sb29cw66hbylcsrz2n";
        libraryHaskellDepends = [
          base heaps mmsyn2-array mmsyn3 parallel
          phonetic-languages-constraints-array
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "pointless-fun_1_1_0_8" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "pointless-fun";
+       version = "1.1.0.8";
+       sha256 = "1s8chhic15ywbd6k6rv9nkh3nb4sibgslnndd954rprz2nj7zn2h";
+       libraryHaskellDepends = [ base ];
+       description = "Some common point-free combinators";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "pointless-haskell" = callPackage
     ({ mkDerivation, base, GHood, process, syb }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "polysemy-check";
-       version = "0.5.0.0";
-       sha256 = "0ch8dzzap6f6bfdyy8i9xdna9l7d3yvx9m7z3pz9pjb19vjxa3f6";
+       version = "0.7.0.0";
+       sha256 = "1sb6gz5wz7b7gxmw0jci9kpaafk4m3rf7ghzsk2fnpvzya5fp6lg";
        libraryHaskellDepends = [
          base containers kind-generics kind-generics-th polysemy QuickCheck
        ];
···
        libraryHaskellDepends = [ base ];
        description = "A redefinition of the Prelude's Enum class in order to render it safe";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "prelude-safeenum_0_1_1_3" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "prelude-safeenum";
+       version = "0.1.1.3";
+       sha256 = "1p6q2kv8gbkhzam03sl2bkjp8xq7q77h88v6afvca3yrlg4mlw62";
+       libraryHaskellDepends = [ base ];
+       description = "A redefinition of the Prelude's Enum class in order to render it safe";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "prelude2010" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "pusher-http-haskell_2_1_0_4" = 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.4";
+       sha256 = "0mqjxx1jb8kvzhnnpfs0r1zkjlb6n0pwqdr6idjsn3w7yxlf5ldw";
+       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
···
        license = lib.licenses.mit;
      }) {};
 
+  "ratel_1_0_16" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, case-insensitive
+     , containers, filepath, hspec, http-client, http-client-tls
+     , http-types, text, uuid
+     }:
+     mkDerivation {
+       pname = "ratel";
+       version = "1.0.16";
+       sha256 = "0n29h5g5bhin3hza334fdmxvk48gnpvg0dldck8rd9kn0713n032";
+       libraryHaskellDepends = [
+         aeson base bytestring case-insensitive containers http-client
+         http-client-tls http-types text uuid
+       ];
+       testHaskellDepends = [ base filepath hspec ];
+       description = "Notify Honeybadger about exceptions";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ratel-wai" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , http-client, ratel, wai
···
        broken = true;
      }) {};
 
-  "rattletrap_11_2_1" = callPackage
+  "rattletrap_11_2_3" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
-     , containers, filepath, http-client, http-client-tls, HUnit, text
+     , containers, filepath, http-client, http-client-tls, text
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "11.2.1";
-       sha256 = "0kmr3178rilifbqs2zkifx47fdq279n4wzxbcr6kn71450xi5xyx";
+       version = "11.2.3";
+       sha256 = "00hqymw1fbg4crgrd5ixivbpx5qblvp109j0yw8nkzidb4bbdhjj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          http-client http-client-tls text
        ];
        executableHaskellDepends = [ base ];
-       testHaskellDepends = [ base bytestring filepath HUnit ];
+       testHaskellDepends = [ base bytestring filepath ];
        description = "Parse and generate Rocket League replays";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
        testHaskellDepends = [ base bytestring ];
        description = "Use RawFilePath instead of FilePath";
        license = lib.licenses.asl20;
+     }) {};
+
+  "rawfilepath_1_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, unix }:
+     mkDerivation {
+       pname = "rawfilepath";
+       version = "1.0.0";
+       sha256 = "0ya68wvafb8zq6d9hlfdr71pnks9a9hln67a2r93pxhz3iz2cv5w";
+       libraryHaskellDepends = [ base bytestring unix ];
+       testHaskellDepends = [ base bytestring ];
+       description = "Use RawFilePath instead of FilePath";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rawr" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "reddit-scrape" = callPackage
+    ({ mkDerivation, base, hspec, http-client, http-client-tls, rio
+     , scalpel
+     }:
+     mkDerivation {
+       pname = "reddit-scrape";
+       version = "0.0.1";
+       sha256 = "1i95qlp84v8q2a7czfl66vqmzypp0pg5qlk25nyg4wsja22pryaj";
+       libraryHaskellDepends = [
+         base http-client http-client-tls rio scalpel
+       ];
+       testHaskellDepends = [
+         base hspec http-client http-client-tls rio scalpel
+       ];
+       description = "Library for getting links from a sub-reddit";
+       license = lib.licenses.bsd2;
+     }) {};
+
   "redesigned-carnival" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
     ({ mkDerivation, base, data-default-class, ghc-prim }:
      mkDerivation {
        pname = "sdp";
-       version = "0.2";
-       sha256 = "1q9l87rvvx7bqbqx1675r2mvj3b2jf0ywa55xcv2ybsl621z52y0";
+       version = "0.2.0.1";
+       sha256 = "1l7bvwqxwn3c8cafbxbkm66cahdpas29h8vgkkkp0rd3y18bvbb5";
        libraryHaskellDepends = [ base data-default-class ghc-prim ];
        description = "Simple Data Processing";
        license = lib.licenses.bsd3;
···
        ];
        description = "A file-packing application";
        license = "GPL";
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sr-extra" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "stm-chans_3_0_0_6" = callPackage
+    ({ mkDerivation, base, stm }:
+     mkDerivation {
+       pname = "stm-chans";
+       version = "3.0.0.6";
+       sha256 = "04hafqjq8ngvhcavkfx88a0zky8yc7i18q2n9ajav03kns1kwvpa";
+       libraryHaskellDepends = [ base stm ];
+       description = "Additional types of channels for STM";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "stm-chunked-queues" = callPackage
     ({ mkDerivation, async, base, HUnit, stm, tasty, tasty-hunit }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
+  "strive_5_0_15" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, data-default, gpolyline
+     , http-client, http-client-tls, http-types, template-haskell, text
+     , time, transformers
+     }:
+     mkDerivation {
+       pname = "strive";
+       version = "5.0.15";
+       sha256 = "1v1m9wdb1kd2pyib6sima4zb0hlwp8hax3mlik3m3ixjbiwfp4ii";
+       libraryHaskellDepends = [
+         aeson base bytestring data-default gpolyline http-client
+         http-client-tls http-types template-haskell text time transformers
+       ];
+       description = "A client for the Strava V3 API";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "strong-path" = callPackage
     ({ mkDerivation, base, exceptions, filepath, hspec, path, tasty
      , tasty-discover, tasty-hspec, tasty-quickcheck, template-haskell
···
        license = lib.licenses.lgpl21Only;
      }) {};
 
+  "swish_0_10_0_7" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath, hashable
+     , HUnit, intern, mtl, network-uri, old-locale, polyparse
+     , semigroups, test-framework, test-framework-hunit, text, time
+     }:
+     mkDerivation {
+       pname = "swish";
+       version = "0.10.0.7";
+       sha256 = "1ii1fcpnhvbid0jwlnya746qh0h4jla8ibx1vn59wyjxb8frlvxk";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base containers directory filepath hashable intern mtl network-uri
+         old-locale polyparse text time
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base containers hashable HUnit network-uri old-locale semigroups
+         test-framework test-framework-hunit text time
+       ];
+       description = "A semantic web toolkit";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "swiss-ephemeris" = callPackage
     ({ mkDerivation, base, directory, hspec, hspec-discover, QuickCheck
      }:
···
      }:
      mkDerivation {
        pname = "synthesizer-alsa";
-       version = "0.5.0.5";
-       sha256 = "09nf2c7nc5dbrd8nskmjrxz8fynnacbnml2wcf5p5qghq2dcd6ma";
-       revision = "1";
-       editedCabalFile = "0acwdxdi8wj63x6f3vcm366hm9liyjbm0czv4mwmm9ryrnc36sc6";
+       version = "0.5.0.6";
+       sha256 = "1jrsl9lbhsyg4cs32c9hq1jflvw9jdgpd9allv89ypw8yw9mmh45";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          transformers utility-ht
        ];
        description = "Control synthesizer effects via ALSA/MIDI";
-       license = "GPL";
+       license = lib.licenses.gpl3Only;
        platforms = [
          "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
        ];
···
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
+  "taskwarrior_0_4_0_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, hspec
+     , hspec-discover, process, QuickCheck, quickcheck-instances, random
+     , text, time, uuid
+     }:
+     mkDerivation {
+       pname = "taskwarrior";
+       version = "0.4.0.0";
+       sha256 = "0f815vfhabry64zjwjp48cdcnk875bx2a8c1ix8lxsa700g2rmav";
+       libraryHaskellDepends = [
+         aeson base bytestring containers process random text time uuid
+       ];
+       testHaskellDepends = [
+         aeson base containers hspec QuickCheck quickcheck-instances text
+         time uuid
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Types and aeson instances for taskwarrior tasks";
+       license = lib.licenses.agpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ maralorn ];
+     }) {};
+
   "tasty" = callPackage
     ({ mkDerivation, ansi-terminal, base, clock, containers, mtl
      , optparse-applicative, stm, tagged, unbounded-delays, unix
···
        pname = "telegram-api";
        version = "0.7.2.0";
        sha256 = "1aixgyxz3izv9z3zwwsbvdnlg4lrhy7aa33zw98v70072a0rqaj2";
+       revision = "1";
+       editedCabalFile = "1mwccj8cs7lcjs1lrwv3wrbj89l5s6s9jpd0svfmmrysn6c20c5a";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers http-api-data http-client
···
        pname = "telegraph";
        version = "1.2.0";
        sha256 = "158wbdzgs4dnrfhhds1dbpmrns8p29qbg5sfph2qaigs1ygf3z58";
+       revision = "1";
+       editedCabalFile = "1rcrrd1jxd5ib00bsw4yyc3a4xfk1m2wyj9naghc08a72xwgxwzw";
        libraryHaskellDepends = [
          aeson base bytestring conduit generic-data-surgery http-client
          http-conduit in-other-words mtl optics-th text
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "time_1_12" = callPackage
+  "time_1_13" = callPackage
     ({ mkDerivation, base, criterion, deepseq, QuickCheck, random
      , tasty, tasty-hunit, tasty-quickcheck
      }:
      mkDerivation {
        pname = "time";
-       version = "1.12";
-       sha256 = "0xavlg1lsq0fip6mwvphr4xz2iykys4wsn468hr8qdg6xqab0x0b";
+       version = "1.13";
+       sha256 = "1i2czgawz0gx3b6mfkcjc8fk4b4jjdlq3znys6kcvzmb6s1lf61d";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base deepseq QuickCheck random tasty tasty-hunit tasty-quickcheck
···
        testHaskellDepends = [ base tasty tasty-golden ];
        description = "Haskell tldr client";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "tldr_0_9_2" = callPackage
+    ({ mkDerivation, ansi-terminal, attoparsec, base, bytestring, cmark
+     , containers, directory, filepath, http-conduit
+     , optparse-applicative, semigroups, tasty, tasty-golden, text, time
+     , zip-archive
+     }:
+     mkDerivation {
+       pname = "tldr";
+       version = "0.9.2";
+       sha256 = "1yypb9zhsj9ks7bbw2sayqv3rn9y8z3w5p1xmsnwb4w99dqmvcx5";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-terminal attoparsec base bytestring cmark containers directory
+         filepath http-conduit optparse-applicative semigroups text time
+         zip-archive
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base tasty tasty-golden ];
+       description = "Haskell tldr client";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tlex" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "unix-bytestring_0_3_7_5" = callPackage
+    ({ mkDerivation, base, bytestring }:
+     mkDerivation {
+       pname = "unix-bytestring";
+       version = "0.3.7.5";
+       sha256 = "003003nh00aww2k8wdygjp0z7f61z8nz8840iinww83xph5wsih5";
+       libraryHaskellDepends = [ base bytestring ];
+       description = "Unix/Posix-specific functions for ByteStrings";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unix-compat" = callPackage
     ({ mkDerivation, base, unix }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "vega-view";
-       version = "0.3.1.7";
-       sha256 = "1181gfxyxf2m3m23xg89kmmp8aizrm9sm908ydbkw885idh2k5x0";
+       version = "0.4.0.0";
+       sha256 = "0sjwgcvymyl74hgfc93l6nj5422d044dkj02mlzvrcfdqhicz96d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "venzone";
-       version = "1.0.0.5";
-       sha256 = "1f8v5xhw6ak6qckrb96rjfpn7h8lm3cq7p0w0k54mrg5ixm4paba";
+       version = "1.0.0.6";
+       sha256 = "1x0034ww13apr1g6mscncacri3nvnmjll7spsip1dnc70ilffk77";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;

pkgs/development/haskell-modules/patches/gogol-core-144.patch

···
+diff --git a/gogol-core.cabal b/gogol-core.cabal
+index 4c47988..caa4796 100644
+--- a/gogol-core.cabal
++++ b/gogol-core.cabal
+@@ -62,7 +62,7 @@ library
+         , lens                 >= 4.4
+         , resourcet            >= 1.1
+         , scientific           >= 0.3
+-        , servant              >= 0.4.4
++        , servant              >= 0.14.1
+         , text                 >= 1.1
+         , unordered-containers >= 0.2.5
+ 
+diff --git a/src/Network/Google/Prelude.hs b/src/Network/Google/Prelude.hs
+index a4ad9de..795c690 100644
+--- a/src/Network/Google/Prelude.hs
++++ b/src/Network/Google/Prelude.hs
+@@ -28,7 +28,7 @@ import Network.HTTP.Client as Export (RequestBody)
+ import Numeric.Natural     as Export (Natural)
+ import Prelude             as Export hiding (product, span, any, Word)
+ import Servant.API         as Export hiding (Headers, Link, getResponse, Stream, ResponseHeader, Header, header)
+-import Servant.Utils.Links as Export hiding (Link)
++import Servant.Links       as Export hiding (Link)
+ import Web.HttpApiData     as Export (FromHttpApiData (..), ToHttpApiData (..))
+ 
+ import Network.Google.Data.Bytes   as Export

pkgs/development/libraries/libbpkg/default.nix

···
+{ lib, stdenv
+, build2
+, fetchurl
+, libbutl
+, enableShared ? !stdenv.hostPlatform.isStatic
+, enableStatic ? !enableShared
+}:
+
+stdenv.mkDerivation rec {
+  pname = "libbpkg";
+  version = "0.13.0";
+  outputs = [ "out" "dev" "doc" ];
+
+  src = fetchurl {
+    url = "https://pkg.cppget.org/1/alpha/build2/libbpkg-${version}.tar.gz";
+    sha256 = "732849cdd5d773c589dd0ac220002fa41424784df10617adc4dea729faafb22b";
+  };
+
+  nativeBuildInputs = [
+    build2
+  ];
+  buildInputs = [
+    libbutl
+  ];
+
+  build2ConfigureFlags = [
+    "config.bin.lib=${build2.configSharedStatic enableShared enableStatic}"
+  ];
+
+  strictDeps = true;
+
+  doCheck = true;
+
+  meta = with lib; {
+    description = "build2 package dependency manager utility library";
+    longDescription = ''
+      This library defines the types and utilities for working with build2 packages.
+      In particular, it provides C++ classes as well as the parser and serializer
+      implementations that can be used to read, manipulate, and write package,
+      repository and signature manifests.
+    '';
+    homepage = "https://build2.org/";
+    changelog = "https://git.build2.org/cgit/libbpkg/log";
+    license = licenses.mit;
+    maintainers = with maintainers; [ r-burns ];
+  };
+}

pkgs/development/libraries/libbutl/default.nix

···
+{ lib, stdenv
+, build2
+, fetchurl
+, libuuid
+, enableShared ? !stdenv.hostPlatform.isStatic
+, enableStatic ? !enableShared
+}:
+
+stdenv.mkDerivation rec {
+  pname = "libbutl";
+  version = "0.13.0";
+
+  outputs = [ "out" "dev" "doc" ];
+
+  src = fetchurl {
+    url = "https://pkg.cppget.org/1/alpha/build2/libbutl-${version}.tar.gz";
+    sha256 = "d7944637ab4a17d3a299c04ff6f146e89b2a0f433ddd9d08d8632a25bae9c9cb";
+  };
+
+  nativeBuildInputs = [
+    build2
+  ];
+
+  strictDeps = true;
+
+  # Should be true for anything built with build2,
+  # but especially important when bootstrapping
+  disallowedReferences = [ build2 ];
+
+  postPatch = lib.optionalString stdenv.isLinux ''
+    substituteInPlace libbutl/uuid-linux.cxx \
+      --replace '"libuuid.so' '"${lib.getLib libuuid}/lib/libuuid.so'
+  '';
+
+  build2ConfigureFlags = [
+    "config.bin.lib=${build2.configSharedStatic enableShared enableStatic}"
+  ];
+
+  # tests broken with -DNDEBUG
+  # https://github.com/build2/libbutl/issues/4
+  # doCheck = true;
+
+  meta = with lib; {
+    description = "build2 utility library";
+    longDescription = ''
+      This library is a collection of utilities that are used throughout the
+      build2 toolchain.
+    '';
+    homepage = "https://build2.org/";
+    changelog = "https://git.build2.org/cgit/libbutl/log";
+    license = licenses.mit;
+    maintainers = with maintainers; [ r-burns ];
+  };
+}

pkgs/development/libraries/libodb-sqlite/default.nix

···
+{ lib, stdenv
+, build2
+, fetchurl
+, libodb
+, sqlite
+, enableShared ? !stdenv.hostPlatform.isStatic
+, enableStatic ? !enableShared
+}:
+stdenv.mkDerivation rec {
+  pname = "libodb-sqlite";
+  version = "2.5.0-b.19";
+
+  outputs = [ "out" "dev" "doc" ];
+
+  src = fetchurl {
+    url = "https://pkg.cppget.org/1/beta/odb/libodb-sqlite-${version}.tar.gz";
+    sha256 = "9443653bfc31d02d0d723f18072f6b04083d090e6580844e33c1e769db122494";
+  };
+
+  nativeBuildInputs = [
+    build2
+  ];
+  buildInputs = [
+    libodb
+  ];
+  propagatedBuildInputs = [
+    sqlite
+  ];
+
+  build2ConfigureFlags = [
+    "config.bin.lib=${build2.configSharedStatic enableShared enableStatic}"
+  ];
+
+  doCheck = true;
+
+  meta = with lib; {
+    description = "SQLite ODB runtime library";
+    longDescription = ''
+      ODB is an object-relational mapping (ORM) system for C++. It provides
+      tools, APIs, and library support that allow you to persist C++ objects
+      to a relational database (RDBMS) without having to deal with tables,
+      columns, or SQL and without manually writing any of the mapping code.
+      For more information see:
+
+      http://www.codesynthesis.com/products/odb/
+
+      This package contains the SQLite ODB runtime library. Every application
+      that includes code generated for the SQLite database will need to link
+      to this library.
+    '';
+    homepage = "https://www.codesynthesis.com/products/odb/";
+    changelog = "https://git.codesynthesis.com/cgit/odb/libodb-sqlite/tree/NEWS";
+    license = licenses.gpl2Only;
+    maintainers = with maintainers; [ r-burns ];
+  };
+}

pkgs/development/libraries/libodb/default.nix

···
+{ lib, stdenv
+, build2
+, fetchurl
+, enableShared ? !stdenv.hostPlatform.isStatic
+, enableStatic ? !enableShared
+}:
+stdenv.mkDerivation rec {
+  pname = "libodb";
+  version = "2.5.0-b.19";
+
+  outputs = [ "out" "dev" "doc" ];
+
+  src = fetchurl {
+    url = "https://pkg.cppget.org/1/beta/odb/libodb-${version}.tar.gz";
+    sha256 = "8180d9d40d8e74ed25b1712953f19379a29abdee3896ae98ba9ade35846adb39";
+  };
+
+  nativeBuildInputs = [ build2 ];
+  build2ConfigureFlags = [
+    "config.bin.lib=${build2.configSharedStatic enableShared enableStatic}"
+  ];
+
+  doCheck = true;
+
+  meta = with lib; {
+    description = "Common ODB runtime library";
+    longDescription = ''
+      ODB is an object-relational mapping (ORM) system for C++. It provides
+      tools, APIs, and library support that allow you to persist C++ objects
+      to a relational database (RDBMS) without having to deal with tables,
+      columns, or SQL and without manually writing any of the mapping code.
+      For more information see:
+
+      http://www.codesynthesis.com/products/odb/
+
+      This package contains the common ODB runtime library. Every application
+      that includes code generated by the ODB compiler will need to link to
+      this library.
+    '';
+    homepage = "https://www.codesynthesis.com/products/odb/";
+    changelog = "https://git.codesynthesis.com/cgit/odb/libodb/tree/NEWS";
+    license = licenses.gpl2Only;
+    maintainers = with maintainers; [ r-burns ];
+  };
+}

pkgs/development/libraries/mtxclient/default.nix

···
     sha256 = "sha256-UKroV1p7jYuNzCAFMsuUsYC/C9AZ1D4rhwpwuER39vc=";
   };
 
+  # This patch should be obsolete and should stop applying the in next release.
+  patches = [ ./fix-compilation-with-olm-3.2.5.patch ];
+
   cmakeFlags = [
     # Network requiring tests can't be disabled individually:
     # https://github.com/Nheko-Reborn/mtxclient/issues/22

pkgs/development/libraries/mtxclient/fix-compilation-with-olm-3.2.5.patch

···
+diff -Naur old/lib/crypto/client.cpp c5pf6ygk9v9rdwwr3dyd24wghflp0vmx-source/lib/crypto/client.cpp
+--- old/lib/crypto/client.cpp	2021-10-22 19:31:52.159836190 +0300
++++ c5pf6ygk9v9rdwwr3dyd24wghflp0vmx-source/lib/crypto/client.cpp	2021-10-22 19:30:42.882010441 +0300
+@@ -37,15 +37,15 @@
+ 
+ };
+ 
+-OlmErrorCode
++mtx::crypto::OlmErrorCode
+ olm_exception::ec_from_string(std::string_view error)
+ {
+         for (size_t i = 0; i < olmErrorStrings.size(); i++) {
+                 if (olmErrorStrings[i] == error)
+-                        return static_cast<OlmErrorCode>(i);
++			return static_cast<mtx::crypto::OlmErrorCode>(i);
+         }
+ 
+-        return OlmErrorCode::UNKNOWN_ERROR;
++        return mtx::crypto::OlmErrorCode::UNKNOWN_ERROR;
+ }
+ 
+ void

pkgs/development/tools/build-managers/build2/bdep.nix

···
+{ lib, stdenv
+, build2
+, fetchurl
+, libbpkg
+, libbutl
+, libodb
+, libodb-sqlite
+, enableShared ? !stdenv.hostPlatform.isStatic
+, enableStatic ? !enableShared
+}:
+
+stdenv.mkDerivation rec {
+  pname = "bdep";
+  version = "0.13.0";
+
+  outputs = [ "out" "doc" "man" ];
+  src = fetchurl {
+    url = "https://pkg.cppget.org/1/alpha/build2/bdep-${version}.tar.gz";
+    sha256 = "8e11b469d875d05c4eb7a228416b78a61c68a49310e5e41db78ed6d048f6ba2a";
+  };
+
+  strictDeps = true;
+  nativeBuildInputs = [
+    build2
+  ];
+  buildInputs = [
+    libbpkg
+    libbutl
+    libodb
+    libodb-sqlite
+  ];
+
+  build2ConfigureFlags = [
+    "config.bin.lib=${build2.configSharedStatic enableShared enableStatic}"
+  ];
+
+  meta = with lib; {
+    description = "build2 project dependency manager";
+    # https://build2.org/bdep/doc/bdep.xhtml
+    longDescription = ''
+      The build2 project dependency manager is used to manage the dependencies
+      of a project during development.
+    '';
+    homepage = "https://build2.org/";
+    changelog = "https://git.build2.org/cgit/bdep/tree/NEWS";
+    license = licenses.mit;
+    maintainers = with maintainers; [ r-burns ];
+  };
+}

pkgs/development/tools/build-managers/build2/bootstrap.nix

···
+{ lib, stdenv
+, fetchurl
+, pkgs
+, fixDarwinDylibNames
+}:
+stdenv.mkDerivation rec {
+  pname = "build2-bootstrap";
+  version = "0.13.0";
+  src = fetchurl {
+    url = "https://download.build2.org/${version}/build2-toolchain-${version}.tar.xz";
+    sha256 = "01hmr5y8aa28qchwy9ci8x5q746flwxmlxarmy4w9zay9nmvryms";
+  };
+  patches = [
+    # Pick up sysdirs from NIX_LDFLAGS
+    ./nix-ldflags-sysdirs.patch
+  ];
+
+  sourceRoot = "build2-toolchain-${version}/build2";
+  makefile = "bootstrap.gmake";
+  enableParallelBuilding = true;
+
+  setupHook = ./setup-hook.sh;
+
+  strictDeps = true;
+
+  propagatedBuildInputs = lib.optionals stdenv.targetPlatform.isDarwin [
+    fixDarwinDylibNames
+  ];
+
+  doCheck = true;
+  checkPhase = ''
+    runHook preCheck
+    build2/b-boot --version
+    runHook postCheck
+  '';
+
+  installPhase = ''
+    runHook preInstall
+    install -D build2/b-boot $out/bin/b
+    runHook postInstall
+  '';
+
+  inherit (pkgs.build2) passthru;
+}

pkgs/development/tools/build-managers/build2/bpkg.nix

···
+{ lib, stdenv
+, build2
+, fetchurl
+, git
+, libbpkg
+, libbutl
+, libodb
+, libodb-sqlite
+, openssl
+, enableShared ? !stdenv.hostPlatform.isStatic
+, enableStatic ? !enableShared
+}:
+
+stdenv.mkDerivation rec {
+  pname = "bpkg";
+  version = "0.13.0";
+
+  outputs = [ "out" "doc" "man" ];
+
+  src = fetchurl {
+    url = "https://pkg.cppget.org/1/alpha/build2/bpkg-${version}.tar.gz";
+    sha256 = "fec41e171c8ea7967bfc44850568cd624def544fd866c383bd413c5b4349e282";
+  };
+
+  strictDeps = true;
+  nativeBuildInputs = [
+    build2
+  ];
+  buildInputs = [
+    libbpkg
+    libbutl
+    libodb
+    libodb-sqlite
+  ];
+  checkInputs = [
+    git
+    openssl
+  ];
+
+  doCheck = !stdenv.isDarwin; # tests hang
+
+  # Failing test
+  postPatch = ''
+    rm tests/rep-create.testscript
+  '';
+
+  build2ConfigureFlags = [
+    "config.bin.lib=${build2.configSharedStatic enableShared enableStatic}"
+  ];
+
+  meta = with lib; {
+    description = "build2 package dependency manager";
+    # https://build2.org/bpkg/doc/bpkg.xhtml
+    longDescription = ''
+      The build2 package dependency manager is used to manipulate build
+      configurations, packages, and repositories.
+    '';
+    homepage = "https://build2.org/";
+    changelog = "https://git.build2.org/cgit/bpkg/tree/NEWS";
+    license = licenses.mit;
+    maintainers = with maintainers; [ r-burns ];
+  };
+}

pkgs/development/tools/build-managers/build2/default.nix

···
-{ stdenv, lib, fetchurl }:
-
+{ stdenv, lib
+, build2
+, fetchurl
+, fetchpatch
+, fixDarwinDylibNames
+, libbutl
+, libpkgconf
+, enableShared ? !stdenv.hostPlatform.isStatic
+, enableStatic ? !enableShared
+}:
+let
+  configSharedStatic = enableShared: enableStatic:
+    if enableShared && enableStatic then "both"
+    else if enableShared then "shared"
+    else if enableStatic then "static"
+    else throw "neither shared nor static libraries requested";
+in
 stdenv.mkDerivation rec {
   pname = "build2";
   version = "0.13.0";
 
+  outputs = [ "out" "dev" "doc" "man" ];
+
+  setupHook = ./setup-hook.sh;
+
   src = fetchurl {
-    url = "https://download.build2.org/${version}/build2-toolchain-${version}.tar.xz";
-    sha256 = "01hmr5y8aa28qchwy9ci8x5q746flwxmlxarmy4w9zay9nmvryms";
+    url = "https://pkg.cppget.org/1/alpha/build2/build2-${version}.tar.gz";
+    sha256 = "aff53a87c23534e0232b5cf746e0be4b2aaa840c3de4e668b98e382a3973c45e";
   };
 
-  dontConfigure = true;
-  dontInstall = true;
+  patches = [
+    # Remove any build/host config entries which refer to nix store paths
+    ./remove-config-store-paths.patch
+    # Pick up sysdirs from NIX_LDFLAGS
+    ./nix-ldflags-sysdirs.patch
+    # Fix stray '-l' linker flags in pkg-config files (remove in next release)
+    (fetchpatch {
+      url = "https://github.com/build2/build2/commit/d51892e33a0fe69e743e02d9620312133a7ac61d.patch";
+      sha256 = "0xzm084bxnfi8lqng0cwxvz8ylbfzk0didbr2wf385gssv4fva81";
+    })
+  ];
 
-  buildPhase = ''
-    runHook preBuild
-    ./build.sh --local --trust yes --install-dir "$out" "$CXX"
-    runHook postBuild
+  strictDeps = true;
+  nativeBuildInputs = [
+    build2
+  ];
+  disallowedReferences = [
+    build2
+    libbutl.dev
+    libpkgconf.dev
+  ];
+  buildInputs = [
+    libbutl
+    libpkgconf
+  ];
+
+  # Build2 uses @rpath on darwin
+  # https://github.com/build2/build2/issues/166
+  # N.B. this only adjusts the install_name after all libraries are installed;
+  # packages containing multiple interdependent libraries may have
+  # LC_LOAD_DYLIB entries containing @rpath, requiring manual fixup
+  propagatedBuildInputs = lib.optionals stdenv.targetPlatform.isDarwin [
+    fixDarwinDylibNames
+  ];
+
+  postPatch = ''
+    patchShebangs --build tests/bash/testscript
   '';
 
+  build2ConfigureFlags = [
+    "config.bin.lib=${configSharedStatic enableShared enableStatic}"
+    "config.cc.poptions+=-I${lib.getDev libpkgconf}/include/pkgconf"
+  ];
+
+  postInstall = lib.optionalString stdenv.isDarwin ''
+    install_name_tool -add_rpath "''${!outputLib}/lib" "''${!outputBin}/bin/b"
+  '';
+
+  passthru = {
+    bootstrap = build2;
+    inherit configSharedStatic;
+  };
+
   meta = with lib; {
     homepage = "https://www.build2.org/";
     description = "build2 build system";
···
       at C/C++ projects as well as mixed-language projects involving
       one of these languages (see bash and rust modules, for example).
     '';
+    changelog = "https://git.build2.org/cgit/build2/tree/NEWS";
     platforms = platforms.all;
     maintainers = with maintainers; [ hiro98 r-burns ];
   };

pkgs/development/tools/build-managers/build2/nix-ldflags-sysdirs.patch

···
+diff --git a/libbuild2/cc/common.cxx b/libbuild2/cc/common.cxx
+index f848003c..0f14f9a5 100644
+--- a/libbuild2/cc/common.cxx
++++ b/libbuild2/cc/common.cxx
+@@ -966,6 +966,17 @@ namespace build2
+     void
+     msvc_extract_library_search_dirs (const strings&, dir_paths&); // msvc.cxx
+ 
++    static strings split (const string& s, const char delim) {
++      stringstream ss (s);
++      string item;
++      strings result;
++
++      while (getline (ss, item, delim)) {
++        result.push_back (item);
++      }
++      return result;
++    }
++
+     dir_paths common::
+     extract_library_search_dirs (const scope& bs) const
+     {
+@@ -987,8 +998,19 @@ namespace build2
+           msvc_extract_library_search_dirs (v, r);
+         else
+           gcc_extract_library_search_dirs (v, r);
++
+       };
+ 
++      // NIX_LDFLAGS are implicitly used when linking,
++      // so its -L flags effectively specify system dirs.
++      // However, they are only enabled when actually linking and are thus
++      // not detected by build2, so we need to manually pick them up here.
++      if (auto s = getenv ("NIX_LDFLAGS")) {
++        // TODO: do we need more robust args splitting here? e.g. shlex.split
++        auto args = split (s.value (), ' ');
++        gcc_extract_library_search_dirs (args, r);
++      }
++
+       // Note that the compiler mode options are in sys_lib_dirs.
+       //
+       if (auto l = bs[c_loptions]) extract (*l, c_loptions);

pkgs/development/tools/build-managers/build2/remove-config-store-paths.patch

···
+--- a/libbuild2/buildfile
++++ b/libbuild2/buildfile
+@@ -68,7 +68,11 @@ config/cxx{host-config}: config/in{host-config}
+   #
+   build2_config = $regex.replace_lines(                 \
++    $regex.replace_lines(                               \
+     $config.save(),                                     \
+     '^ *(#|config\.dist\.|config\.install\.chroot).*$', \
+     [null],                                             \
++    return_lines),                                      \
++    '^.*'$getenv(NIX_STORE)'/[a-z0-9]{32}-.*$',         \
++    [null],                                             \
+     return_lines)
+ 

pkgs/development/tools/build-managers/build2/setup-hook.sh

···
+build2ConfigurePhase() {
+    runHook preConfigure
+
+    local flagsArray=(
+        "config.c=$CC"
+        "config.cxx=$CXX"
+        "config.cc.coptions+=-O2"
+        "config.cc.poptions+=-DNDEBUG"
+        "config.install.root=$prefix"
+        "config.install.bin=${!outputBin}/bin"
+        "config.install.doc=${!outputDoc}/share/doc/${shareDocName}"
+        "config.install.exec_root=${!outputBin}"
+        "config.install.include=${!outputInclude}/include"
+        "config.install.lib=${!outputLib}/lib"
+        "config.install.libexec=${!outputLib}/libexec"
+        "config.install.man=${!outputDoc}/share/man"
+        "config.install.sbin=${!outputBin}/sbin"
+        "config.install.bin.mode=755"
+        $build2ConfigureFlags "${build2ConfigureFlagsArray[@]}"
+    )
+
+    echo 'configure flags' "${flagsArray[@]}"
+
+    b configure "${flagsArray[@]}"
+
+    runHook postConfigure
+}
+
+build2BuildPhase() {
+    runHook preBuild
+
+    local flagsArray=(
+        $build2BuildFlags "${build2BuildFlagsArray[@]}"
+    )
+
+    echo 'build flags' "${flagsArray[@]}"
+    b "${flagsArray[@]}"
+
+    runHook postBuild
+}
+
+build2CheckPhase() {
+    runHook preCheck
+
+    local flagsArray=(
+        $build2CheckFlags "${build2CheckFlags[@]}"
+    )
+
+    echo 'check flags' "${flagsArray[@]}"
+
+    b test ${build2Dir:-.} "${flagsArray[@]}"
+
+    runHook postCheck
+}
+
+build2InstallPhase() {
+    runHook preInstall
+
+    local flagsArray=(
+        $build2InstallFlags "${build2InstallFlagsArray[@]}"
+        ${installTargets:-}
+    )
+
+    echo 'install flags' "${flagsArray[@]}"
+    b install "${flagsArray[@]}"
+
+    runHook postInstall
+}
+
+if [ -z "${dontUseBuild2Configure-}" -a -z "${configurePhase-}" ]; then
+    setOutputFlags=
+    configurePhase=build2ConfigurePhase
+fi
+
+if [ -z "${dontUseBuild2Build-}" -a -z "${buildPhase-}" ]; then
+    buildPhase=build2BuildPhase
+fi
+
+if [ -z "${dontUseBuild2Check-}" -a -z "${checkPhase-}" ]; then
+    checkPhase=build2CheckPhase
+fi
+
+if [ -z "${dontUseBuild2Install-}" -a -z "${installPhase-}" ]; then
+    installPhase=build2InstallPhase
+fi

pkgs/servers/sql/pgbouncer/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "pgbouncer";
-  version = "1.15.0";
+  version = "1.16.0";
 
   src = fetchurl {
     url = "https://pgbouncer.github.io/downloads/files/${version}/${pname}-${version}.tar.gz";
-    sha256 = "100ksf2wcdrsscaiq78s030mb48hscjr3kfbm9h6y9d6i8arwnp0";
+    sha256 = "0li66jk1v07bpfmmqzcqjn5vkhglfhwnbncc5bpalg5qidhr38x4";
   };
 
   nativeBuildInputs = [ pkg-config ];
···
     homepage = "https://pgbouncer.github.io";
     description = "Lightweight connection pooler for PostgreSQL";
     license = licenses.isc;
+    maintainers = with maintainers; [ _1000101 ];
     platforms = platforms.all;
   };
 }

pkgs/tools/misc/pgmetrics/default.nix

···
 
 buildGoModule rec {
   pname = "pgmetrics";
-  version = "1.11.0";
+  version = "1.12.0";
 
   src = fetchFromGitHub {
-    owner  = "rapidloop";
-    repo   = pname;
-    rev    = "v${version}";
-    sha256 = "sha256-8E4rciuoZrj8Oz2EXqtFgrPxvb8GJO3n1s2FpXrR0Q0=";
+    owner = "rapidloop";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1fwc4qc17fqmzx08kiyfx5iwgzr14dxk9i8zjd9bq5gk281v0ybd";
   };
 
-  vendorSha256 = "sha256-scaaRjaDE/RG6Ei83CJBkfQCd1e5pH/Cs2vEbdl9Oyg=";
+  vendorSha256 = "18da45axjl8l3qb6f3w5v2c7clz4bjhdz2bck20j729k7693hpsl";
 
   doCheck = false;
 

pkgs/top-level/all-packages.nix

···
 
   buck = callPackage ../development/tools/build-managers/buck { };
 
-  build2 = callPackage ../development/tools/build-managers/build2 { };
+  build2 = callPackage ../development/tools/build-managers/build2 {
+    # Break cycle by using self-contained toolchain for bootstrapping
+    build2 = buildPackages.callPackage ../development/tools/build-managers/build2/bootstrap.nix { };
+  };
+
+  # Dependency of build2, must also break cycle for this
+  libbutl = callPackage ../development/libraries/libbutl {
+    build2 = build2.bootstrap;
+  };
+
+  libbpkg = callPackage ../development/libraries/libbpkg { };
+  libodb = callPackage ../development/libraries/libodb { };
+  libodb-sqlite = callPackage ../development/libraries/libodb-sqlite { };
+  bdep = callPackage ../development/tools/build-managers/build2/bdep.nix { };
+  bpkg = callPackage ../development/tools/build-managers/build2/bpkg.nix { };
 
   buildkite-agent = callPackage ../development/tools/continuous-integration/buildkite-agent { };
 
···
   msitools = callPackage ../development/tools/misc/msitools { };
 
   haskell-ci = haskell.lib.justStaticExecutables haskellPackages.haskell-ci;
+  haskell-ci-unstable = lowPrio (haskell.lib.justStaticExecutables haskellPackages.haskell-ci-unstable);
 
   neoload = callPackage ../development/tools/neoload {
     licenseAccepted = (config.neoload.accept_license or false);
···
     pkg-config = pkgconf-unwrapped;
     baseBinName = "pkgconf";
   };
+  libpkgconf = pkgconf-unwrapped;
 
   pkg-config-unwrapped = callPackage ../development/tools/misc/pkg-config { };
   pkg-config = callPackage ../build-support/pkg-config-wrapper {