Merge staging-next into staging

pkgs/applications/networking/cluster/kube-capacity/default.nix

···
+{ stdenv, lib, buildGoModule, fetchFromGitHub }:
+
+buildGoModule rec {
+  pname = "kube-capacity";
+  version = "0.5.1";
+
+  src = fetchFromGitHub {
+    rev = "v${version}";
+    owner = "robscott";
+    repo = pname;
+    sha256 = "127583hmpj04y522wir76a39frm6zg9z7mb4ny5lxxjqhn0q0cd5";
+  };
+
+  vendorSha256 = "sha256-EgLWZs282IV1euCUCc5ucf267E2Z7GF9SgoImiGvuVM=";
+
+  meta = with lib; {
+    description =
+      "A simple CLI that provides an overview of the resource requests, limits, and utilization in a Kubernetes cluster";
+    homepage = "https://github.com/robscott/kube-capacity";
+    changelog = "https://github.com/robscott/kube-capacity/releases/tag/v${version}";
+    license = licenses.asl20;
+    maintainers = [ maintainers.bryanasdev000 ];
+  };
+}

pkgs/applications/networking/cluster/starboard/default.nix

···
 
 buildGoModule rec {
   pname = "starboard";
-  version = "0.9.1";
+  version = "0.9.2";
 
   src = fetchFromGitHub {
     owner = "aquasecurity";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-ZIAdYuJ8LS8x2h+VXQrkgdmKkw9VKl7FcnOVZNSnXM0=";
+    sha256 = "sha256-w+xaZPEMmJYDPQG4MuAlWMhwhEyeVcpaeDwqsnIbIHA=";
   };
 
   vendorSha256 = "sha256-aVKQcRZgxhIph+y28HhR15DUjwiz/4+t1bMrYXjPW7Q=";

pkgs/applications/networking/instant-messengers/element/element-desktop-package.json

···
   "name": "element-desktop",
   "productName": "Element",
   "main": "src/electron-main.js",
-  "version": "1.7.20",
+  "version": "1.7.21",
   "description": "A feature-rich client for Matrix.org",
   "author": "Element",
   "repository": {

pkgs/applications/networking/instant-messengers/element/element-desktop.nix

···
 
 let
   executableName = "element-desktop";
-  version = "1.7.20";
+  version = "1.7.21";
   src = fetchFromGitHub {
     owner = "vector-im";
     repo = "element-desktop";
     rev = "v${version}";
-    sha256 = "sha256-kQMswcEGsefQ8HCWxYPgvxOKP5cgvXx8oCl5Inh6sOg=";
+    sha256 = "sha256-tpFiKaJB6KN97ipN3OCTyxpiS0b980MQ1Ynxj8CjCuI=";
   };
 in mkYarnPackage rec {
   name = "element-desktop-${version}";

pkgs/applications/networking/instant-messengers/element/element-web.nix

···
 
 in stdenv.mkDerivation rec {
   pname = "element-web";
-  version = "1.7.20";
+  version = "1.7.21";
 
   src = fetchurl {
     url = "https://github.com/vector-im/element-web/releases/download/v${version}/element-v${version}.tar.gz";
-    sha256 = "sha256-8R7l/Pmymd5+/Fri7z2/TDj1h2FL0QgLICoXajePing=";
+    sha256 = "sha256-JJXl+jDlXw8fZ1ZeeAACvilbqG9zanCmBsHy6BEla8M=";
   };
 
   installPhase = ''

pkgs/applications/networking/ncgopher/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "ncgopher";
-  version = "0.1.5";
+  version = "0.2.0";
 
   src = fetchFromGitHub {
     owner = "jansc";
     repo = "ncgopher";
     rev = "v${version}";
-    sha256 = "1mv89sanmr49b9za95jl5slpq960b246j2054r8xfafzqmbp44af";
+    sha256 = "sha256-Yny5zZe5x7/pWda839HcFkHFuL/jl1Q7ykTZzKy871I=";
   };
 
-  cargoSha256 = "12r4vgrg2bkr3p61yxcsg02kppg84vn956l0v1vb08i94rxzc8zk";
+  cargoSha256 = "sha256-IsRaDhnRamMSbtXG1r1j0jZYjFiSjRdwOaUVyqy4ZJw=";
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [

pkgs/applications/version-management/git-and-tools/glab/default.nix

···
 
 buildGoModule rec {
   pname = "glab";
-  version = "1.14.0";
+  version = "1.15.0";
 
   src = fetchFromGitHub {
     owner = "profclems";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-JvHuOMpt62tw7ewDev7unAgZGV+ZSo6wDuiPhWap2v0=";
+    sha256 = "sha256-wOeWqgN0VYmTXPTU3z5Utau8diW18QKV7w/2y86R8U0=";
   };
 
-  vendorSha256 = "sha256-0nnrH3GJhd4wlRETo9iSlFkXq358m30k7Fsb5haHlpQ=";
+  vendorSha256 = "sha256-Ge3nwI0cY2JxRTn3EZtlal5c6A6TIKfH/CkJnQ1C6PY=";
   runVend = true;
 
   # Tests are trying to access /homeless-shelter

pkgs/applications/video/cinelerra/default.nix

···
-{ lib, stdenv, fetchFromGitHub, fetchpatch, autoconf, automake, libtool
+{ lib, stdenv, fetchFromGitHub, autoconf, automake, libtool
 , pkg-config, faad2, faac, a52dec, alsaLib, fftw, lame, libavc1394
 , libiec61883, libraw1394, libsndfile, libvorbis, libogg, libjpeg
 , libtiff, freetype, mjpegtools, x264, gettext, openexr
···
 , fontconfig, intltool }:
 
 stdenv.mkDerivation {
-  name = "cinelerra-cv-2018-05-16";
+  name = "cinelerra-cv-2021-02-14";
 
   src = fetchFromGitHub {
     owner = "cinelerra-cv-team";
     repo = "cinelerra-cv";
-    rev = "d9c0dbf4393717f0a42f4b91c3e1ed5b16f955dc";
-    sha256 = "0a8kfm1v96sv6jh4568crg6nkr6n3579i9xksfj8w199s6yxzsbk";
+    rev = "7d0e8ede557d0cdf3606e0a8d97166a22f88d89e";
+    sha256 = "0n84y2wp47y89drc48cm1609gads5c6saw6c6bqcf5c5wcg1yfbj";
   };
-
-  patches = [
-    # avoid gcc10 error about narrowing
-    (fetchpatch {
-      url = "https://github.com/cinelerra-cv-team/cinelerra-cv/pull/2/commits/a1b2d9c3bd5730ec0284894f3d81892af3e77f1f.patch";
-      sha256 = "1cjyv1m174dblpa1bs5dggk24h4477zqvc5sbfc0m5rpkndx5ycp";
-    })
-  ];
 
   preConfigure = ''
     find -type f -print0 | xargs --null sed -e "s@/usr/bin/perl@${perl}/bin/perl@" -i
···
     ];
 
   meta = with lib; {
-    description = "Video Editor";
-    homepage = "https://www.cinelerra.org/";
+    description = "Professional video editing and compositing environment (community version)";
+    homepage = "http://cinelerra-cv.wikidot.com/";
     maintainers = with maintainers; [ marcweber ];
     license = licenses.gpl2Only;
   };

pkgs/applications/virtualization/qemu/default.nix

···
     sha256 = "1g0pvx4qbirpcn9mni704y03n3lvkmw2c0rbcwvydyr8ns4xh66b";
   };
 
-  nativeBuildInputs = [ python python.pkgs.sphinx pkg-config flex bison meson ninja autoPatchelfHook ]
-    ++ optionals gtkSupport [ wrapGAppsHook ];
+  nativeBuildInputs = [ python python.pkgs.sphinx pkg-config flex bison meson ninja ]
+    ++ optionals gtkSupport [ wrapGAppsHook ]
+    ++ optionals stdenv.isLinux [ autoPatchelfHook ];
   buildInputs =
     [ zlib glib perl pixman
       vde2 texinfo makeWrapper lzo snappy
···
     # this script isn't marked as executable b/c it's indirectly used by meson. Needed to patch its shebang
     chmod +x ./scripts/shaderinclude.pl
     patchShebangs .
+    # avoid conflicts with libc++ include for <version>
+    mv VERSION QEMU_VERSION
+    substituteInPlace meson.build \
+      --replace "'VERSION'" "'QEMU_VERSION'"
   '' + optionalString stdenv.hostPlatform.isMusl ''
     NIX_CFLAGS_COMPILE+=" -D_LINUX_SYSINFO_H"
   '';
···
       "--enable-guest-agent"
       "--sysconfdir=/etc"
     ]
-    # disable sysctl check on darwin.
-    ++ optional stdenv.isDarwin "--cpu=x86_64"
     ++ optional numaSupport "--enable-numa"
     ++ optional seccompSupport "--enable-seccomp"
     ++ optional smartcardSupport "--enable-smartcard"

pkgs/data/icons/luna-icons/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "luna-icons";
-  version = "0.9.2";
+  version = "1.0";
 
   src = fetchFromGitHub {
     owner = "darkomarko42";
     repo = pname;
     rev = version;
-    sha256 = "0ajx7yjkgj5ynbjmd6k3cldjn0qr51h6k80hjgr7vqd0ybyylh5p";
+    sha256 = "1gggsd7scf15vrpgzvskx4p3jifnjdx0aqndqhvpc6ksdbh3nzqd";
   };
 
   nativeBuildInputs = [
···
 
     mkdir -p $out/share/icons
     cp -a Luna* $out/share/icons
-
-    # remove files with spaces in the name, otherwise
-    # gtk-update-icon-cache fails with the message "The generated cache
-    # was invalid"
-    # https://github.com/darkomarko42/Luna-Icons/issues/2
-    rm "$out/share/icons/Luna/scalable/apps/yast-checkmedia (copia).svg"
 
     for theme in $out/share/icons/*; do
       gtk-update-icon-cache "$theme"

pkgs/development/compilers/cudatoolkit/default.nix

···
 let
   common = callPackage ./common.nix;
 in rec {
-  cudatoolkit_6 = common {
-    version = "6.0.37";
-    url = "http://developer.download.nvidia.com/compute/cuda/6_0/rel/installers/cuda_6.0.37_linux_64.run";
-    sha256 = "991e436c7a6c94ec67cf44204d136adfef87baa3ded270544fa211179779bc40";
-    gcc = gcc48;
-  };
-
-  cudatoolkit_6_5 = common {
-    version = "6.5.19";
-    url = "http://developer.download.nvidia.com/compute/cuda/6_5/rel/installers/cuda_6.5.19_linux_64.run";
-    sha256 = "1x9zdmk8z784d3d35vr2ak1l4h5v4jfjhpxfi9fl9dvjkcavqyaj";
-    gcc = gcc48;
-  };
-
-  cudatoolkit_7 = common {
-    version = "7.0.28";
-    url = "http://developer.download.nvidia.com/compute/cuda/7_0/Prod/local_installers/cuda_7.0.28_linux.run";
-    sha256 = "1km5hpiimx11jcazg0h3mjzk220klwahs2vfqhjavpds5ff2wafi";
-    gcc = gcc6;
-  };
-
-  cudatoolkit_7_5 = common {
-    version = "7.5.18";
-    url = "http://developer.download.nvidia.com/compute/cuda/7.5/Prod/local_installers/cuda_7.5.18_linux.run";
-    sha256 = "1v2ylzp34ijyhcxyh5p6i0cwawwbbdhni2l5l4qm21s1cx9ish88";
-    gcc = gcc6;
-  };
-
-  cudatoolkit_8 = common {
-    version = "8.0.61.2";
-    url = "https://developer.nvidia.com/compute/cuda/8.0/Prod2/local_installers/cuda_8.0.61_375.26_linux-run";
-    sha256 = "1i4xrsqbad283qffvysn88w2pmxzxbbby41lw0j1113z771akv4w";
-    runPatches = [
-      (fetchurl {
-        url = "https://developer.nvidia.com/compute/cuda/8.0/Prod2/patches/2/cuda_8.0.61.2_linux-run";
-        sha256 = "1iaz5rrsnsb1p99qiqvxn6j3ksc7ry8xlr397kqcjzxqbljbqn9d";
-      })
-    ];
-    gcc = gcc6;
-  };
-
   cudatoolkit_9_0 = common {
     version = "9.0.176.1";
     url = "https://developer.nvidia.com/compute/cuda/9.0/Prod/local_installers/cuda_9.0.176_384.81_linux-run";

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

···
 
   "Rattus" = callPackage
     ({ mkDerivation, base, Cabal, containers, ghc, ghc-prim
-     , simple-affine-space, transformers
+     , simple-affine-space
      }:
      mkDerivation {
        pname = "Rattus";
-       version = "0.5";
-       sha256 = "1dh6ln8awqhgnk7hqh4zdkv4pqy3wmsqbmqrd016raf8vjbc1i3m";
+       version = "0.4";
+       sha256 = "1sgr33yq5l43k3b8nwx7m6wrygv5k8d8yigzms3p6pq5pk3g5sq1";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
-         base containers ghc ghc-prim simple-affine-space transformers
+         base containers ghc ghc-prim simple-affine-space
        ];
        testHaskellDepends = [ base containers ];
        description = "A modal FRP language";
···
        platforms = lib.platforms.none;
      }) {};
 
-  "Win32_2_11_1_0" = callPackage
+  "Win32_2_11_0_0" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "Win32";
-       version = "2.11.1.0";
-       sha256 = "18rsfx3ca8r7y4ifxn1mggn8j6ppgkn698wsq0pwqb63riva09rk";
+       version = "2.11.0.0";
+       sha256 = "179v0jypafjnh98gl8wr6z6pq1r5h740xzm2b6axd2d33zlnacfm";
        description = "A binding to Windows Win32 API";
        license = lib.licenses.bsd3;
        platforms = lib.platforms.none;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "aeson-combinators_0_0_4_1" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, criterion
-     , deepseq, doctest, fail, hspec, scientific, text, time
-     , time-compat, unordered-containers, utf8-string, uuid-types
-     , vector, void
-     }:
-     mkDerivation {
-       pname = "aeson-combinators";
-       version = "0.0.4.1";
-       sha256 = "1nvw5n7kfqrrci76350zd3mqvssb775ka4044kxgw0bhdzy3gcpg";
-       libraryHaskellDepends = [
-         aeson base bytestring containers fail scientific text time
-         time-compat unordered-containers uuid-types vector void
-       ];
-       testHaskellDepends = [
-         aeson base bytestring doctest hspec text utf8-string
-       ];
-       benchmarkHaskellDepends = [
-         aeson base bytestring criterion deepseq text
-       ];
-       description = "Aeson combinators for dead simple JSON decoding";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "aeson-commit" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, mtl, tasty, tasty-hspec
      , text
···
      }:
      mkDerivation {
        pname = "approx";
-       version = "0.1.0.1";
-       sha256 = "0vzi0ai7lf7ji2lbf9v412fvrins7acy0dqs4j8ylfd1chck1w99";
+       version = "0.1.0.0";
+       sha256 = "1vc6k0w4zr355gfvprb5syh5jpmkdvp6wjibi4l95q9zwwdwhjn2";
        revision = "1";
-       editedCabalFile = "0kj9qqfv8fzg5b6l33avflxjlmd52wjsjridff1d5n071dnif37y";
+       editedCabalFile = "0k34bjsazp4wbv7zzmvh5vnqv7yzyq20h99q30mcrn4g2bvpc0q1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          base containers hashable QuickCheck text time unordered-containers
          vector
        ];
-       description = "Easy-to-use emulation of approximate, ranges and tolerances in Haskell";
+       description = "Easy-to-use reasonable way of emulating approximate in Haskell";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
        pname = "asn1-encoding";
        version = "0.9.6";
        sha256 = "02nsr30h5yic1mk7znf0q4z3n560ip017n60hg7ya25rsfmxxy6r";
-       revision = "2";
-       editedCabalFile = "16503ryhq15f2rfdav2qnkq11dg2r3vk3f9v64q9dmxf8dh8zv97";
+       revision = "1";
+       editedCabalFile = "19nq8g1v323p47cqlc4m9r6li35dd3cmcd7k486jw24cijkdjm9n";
        libraryHaskellDepends = [ asn1-types base bytestring hourglass ];
        testHaskellDepends = [
          asn1-types base bytestring hourglass mtl tasty tasty-quickcheck
···
        pname = "assoc";
        version = "1.0.2";
        sha256 = "0kqlizznjy94fm8zr1ng633yxbinjff7cnsiaqs7m33ix338v66q";
-       revision = "1";
-       editedCabalFile = "17ycclzwnysca80frsyyb6sdd2r5p83lkgwxjjnjg6j62pvf8958";
        libraryHaskellDepends = [ base bifunctors tagged ];
        description = "swap and assoc: Symmetric and Semigroupy Bifunctors";
        license = lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
-  "bytestring_0_11_1_0" = callPackage
-    ({ mkDerivation, base, deepseq, dlist, ghc-prim, integer-gmp
-     , random, tasty, tasty-bench, tasty-hunit, tasty-quickcheck
-     , transformers
-     }:
+  "bytestring_0_11_0_0" = callPackage
+    ({ mkDerivation, base, deepseq, ghc-prim, integer-gmp }:
      mkDerivation {
        pname = "bytestring";
-       version = "0.11.1.0";
-       sha256 = "1a29kwczd1hcpir691x936i9c5ys9d7m1lyby48djs9w54ksy1jw";
+       version = "0.11.0.0";
+       sha256 = "03fwkbn52946y2l1ddrqq1jp8l9bhgi0gwxpz1wqqsn6n2vz5rrj";
+       revision = "1";
+       editedCabalFile = "0qhx61v75cqpgrb88h5gpc4a6vg17dgrw555q2kgi2hvip61z5lr";
        libraryHaskellDepends = [ base deepseq ghc-prim integer-gmp ];
-       testHaskellDepends = [
-         base deepseq dlist ghc-prim tasty tasty-hunit tasty-quickcheck
-         transformers
-       ];
-       benchmarkHaskellDepends = [
-         base deepseq dlist random tasty-bench
-       ];
        description = "Fast, compact, strict and lazy byte strings with a list interface";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "capnp";
-       version = "0.10.0.1";
-       sha256 = "1p5vx7gcswz08f790swb8pi2ckbphqr76j8gav4rvrbalscd3zvf";
+       version = "0.10.0.0";
+       sha256 = "054cy2rr2hg0brrbxff4my3q2fzr1qk7ik2xyip65dq54958ibqk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "cmdargs_0_10_21" = callPackage
-    ({ mkDerivation, base, filepath, process, template-haskell
-     , transformers
-     }:
-     mkDerivation {
-       pname = "cmdargs";
-       version = "0.10.21";
-       sha256 = "0xfabq187n1vqrnnm4ciprpl0dcjq97rksyjnpcniwva9rffmn7p";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base filepath process template-haskell transformers
-       ];
-       description = "Command line argument processing";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "cmdargs-browser" = callPackage
     ({ mkDerivation, base, bytestring, cmdargs, directory, filepath
      , http-types, js-jquery, process, text, transformers, wai
···
      }:
      mkDerivation {
        pname = "coinbase-pro";
-       version = "0.9.0.0";
-       sha256 = "1wnjpm49gy75nl3m01bablchbk7clsgf4x53xqx5k2bsvn1xd1n1";
+       version = "0.8.0.0";
+       sha256 = "021c05qkrvgxlylvrrlb81bjxl49v5varn0fi5wqs5sda15766n3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "criterion-cmp" = callPackage
-    ({ mkDerivation, ansi-terminal, base, boxes, bytestring, cassava
-     , containers, filepath, optparse-applicative, vector
-     }:
-     mkDerivation {
-       pname = "criterion-cmp";
-       version = "0.1.0.0";
-       sha256 = "0p9l9c89bg1n7xjdq3npvknlfb36gkvpgwhq7i0qd2g20ysdxppd";
-       isLibrary = false;
-       isExecutable = true;
-       executableHaskellDepends = [
-         ansi-terminal base boxes bytestring cassava containers filepath
-         optparse-applicative vector
-       ];
-       description = "A simple tool for comparing in Criterion benchmark results";
-       license = lib.licenses.bsd3;
-     }) {};
-
   "criterion-compare" = callPackage
     ({ mkDerivation, base, bytestring, cassava, Chart, Chart-diagrams
      , clay, colour, containers, data-default, filepath, lens, lucid
···
        pname = "dhall";
        version = "1.38.0";
        sha256 = "0ifxi9i7ply640s2cgljjczvmblgz0ryp2p9yxgng3qm5ai58229";
-       revision = "2";
-       editedCabalFile = "13ppbn4kcrfls9fm9sqjwa4hb4nj8q6fqfxj3a62vck7qc1rbvn0";
+       revision = "1";
+       editedCabalFile = "067hh41cnmjskf3y3kzlwsisw6v5bh9mbmhg5jfapm1y5xp6gw9r";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "dhall-bash";
        version = "1.0.36";
        sha256 = "0hg45xjl1pcla9xbds40qrxcx2h6b4ysw8kbx8hpnaqaazr2jrw0";
-       revision = "1";
-       editedCabalFile = "1jc74gydr3yx01xp1a69a3g9mbfqyzsmv1053xm51bcxxv6p6z9d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dhall-docs";
        version = "1.0.4";
        sha256 = "0x6x5b9kh0in35jsgj2dghyxsqjdjrw7s9kngyjcn7v2ycklcifl";
-       revision = "3";
-       editedCabalFile = "116m74khdfx57ghrid1myqyj8acrhzhnjzjmxnsn3yghdan29797";
+       revision = "2";
+       editedCabalFile = "1y8aaph8zg3lp53apvkg0s6zviz3sa82qq1dnbqn6xjgb1dqjr7z";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "dhall-json";
        version = "1.7.5";
        sha256 = "1fpkp8xkcw2abcigypyl0ji6910jyshlqwhf48yfwn6dsgbyw6iy";
-       revision = "2";
-       editedCabalFile = "0181ma0qzkcfg4g5fcyivmjfn542m9cmq74r6hxilfjvfzhk7fqw";
+       revision = "1";
+       editedCabalFile = "0vl9vb84r1fz80jvqxaq4624pk67hxkm3vsx5j0l3bz8mk439yzn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dhall-lsp-server";
        version = "1.0.13";
        sha256 = "0cj51xdmpp0w7ndzbz4yn882agvhbnsss3myqlhfi4y91lb8f1ak";
-       revision = "3";
-       editedCabalFile = "19c902vjdnikwma21gjggpc7x9sjdqbirksqw85f1n9jkrbya375";
+       revision = "2";
+       editedCabalFile = "1gmcfp6i36y00z4gyllcq62rgpjz2x7fgdy4n6d24ygczpqbwy9k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dhall-yaml";
        version = "1.2.5";
        sha256 = "0fax4p85344yrzk1l21j042mm02p0idp396vkq71x3dpiniq0mwf";
-       revision = "1";
-       editedCabalFile = "034rykrnmsnc9v9hsblkzjp26b8wv265sd31gwhqxy2358y4s33h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Pure Haskell solver routines used by diagrams";
        license = lib.licenses.bsd3;
-     }) {};
-
-  "diagrams-solve_0_1_3" = callPackage
-    ({ mkDerivation, base, deepseq, tasty, tasty-hunit
-     , tasty-quickcheck
-     }:
-     mkDerivation {
-       pname = "diagrams-solve";
-       version = "0.1.3";
-       sha256 = "09qqwcvbvd3a0j5fnp40dbzw0i3py9c7kgizj2aawajwbyjvpd17";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [
-         base deepseq tasty tasty-hunit tasty-quickcheck
-       ];
-       description = "Pure Haskell solver routines used by diagrams";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "diagrams-svg" = callPackage
···
 
   "evdev" = callPackage
     ({ mkDerivation, base, bytestring, c2hs, containers, extra
-     , filepath-bytestring, libevdev, monad-loops, rawfilepath, tasty
-     , tasty-hunit, tasty-quickcheck, time, unix
+     , libevdev, monad-loops, time, unix
      }:
      mkDerivation {
        pname = "evdev";
-       version = "2.1.0";
-       sha256 = "1gzf9hpsi2dmcgsifq5z91ing9b5k56mm2hx9wbsa180pmq30lj3";
+       version = "2.0.0.1";
+       sha256 = "0ryq50g7z70rnv07pnvwssl0qrvhbljkq9yk1z8gj9kvqdsw9cmg";
        libraryHaskellDepends = [
-         base bytestring containers extra filepath-bytestring monad-loops
-         rawfilepath time unix
+         base bytestring containers extra monad-loops time unix
        ];
        libraryPkgconfigDepends = [ libevdev ];
        libraryToolDepends = [ c2hs ];
-       testHaskellDepends = [
-         base bytestring containers extra filepath-bytestring monad-loops
-         rawfilepath tasty tasty-hunit tasty-quickcheck time unix
-       ];
        description = "Bindings to libevdev";
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) libevdev;};
···
        pname = "evdev-streamly";
        version = "0.0.1.0";
        sha256 = "1bzmxkg5y7w6v5l6q5vzhr19j5vwbx4p4qxdq72f7f714ihn8nyp";
-       revision = "1";
-       editedCabalFile = "02xnb49zwr39ziq2xrwnnddzxr1ppwig441i3074g1w0ng5cf2gj";
        libraryHaskellDepends = [
          base bytestring containers evdev extra posix-paths rawfilepath
          streamly streamly-fsnotify unix
···
      }:
      mkDerivation {
        pname = "exh";
-       version = "1.0.2";
-       sha256 = "10pvr8ya2f7arp8cqi4g97dpqin1h8n0xmnihqszchcils0v2ayn";
+       version = "1.0.0";
+       sha256 = "0s5br96spx4v67mvl09w4kpcwvps65zp6qx5qpvrq63a0ncclp7l";
        libraryHaskellDepends = [
          aeson base bytestring conduit containers html-conduit http-client
          in-other-words language-javascript megaparsec optics-core optics-th
···
        license = lib.licenses.bsd2;
      }) {};
 
-  "ghc-typelits-natnormalise_0_7_4" = callPackage
-    ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra
-     , integer-gmp, tasty, tasty-hunit, template-haskell, transformers
-     }:
-     mkDerivation {
-       pname = "ghc-typelits-natnormalise";
-       version = "0.7.4";
-       sha256 = "0d8wwb1i6jj11cylf2n42r08hfygv9gwy89xyxp4kdclyw9mfwrp";
-       libraryHaskellDepends = [
-         base containers ghc ghc-tcplugins-extra integer-gmp transformers
-       ];
-       testHaskellDepends = [ base tasty tasty-hunit template-haskell ];
-       description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
-       license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "ghc-typelits-presburger" = callPackage
     ({ mkDerivation, base, containers, equational-reasoning, ghc
      , ghc-tcplugins-extra, mtl, pretty, reflection, syb, tasty
···
 
   "ghcprofview" = callPackage
     ({ mkDerivation, aeson, base, containers, ghc-prof, gi-gtk
-     , haskell-gi-base, mtl, regex-tdfa, scientific, text
+     , haskell-gi-base, regex-tdfa, regex-tdfa-text, scientific, text
      }:
      mkDerivation {
        pname = "ghcprofview";
-       version = "0.1.0.1";
-       sha256 = "0lk5ky0vrymzhdzfrdvq25kpphg69f1m6524jhr57dnss5syz1iv";
+       version = "0.1.0.0";
+       sha256 = "103186dik439sdzz1w6dr98s1sfghjxdkp51mh18wrcwdbdb9r3a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         aeson base containers ghc-prof gi-gtk haskell-gi-base mtl
-         regex-tdfa scientific text
+         aeson base containers ghc-prof gi-gtk haskell-gi-base regex-tdfa
+         regex-tdfa-text scientific text
        ];
        description = "GHC .prof files viewer";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "gltf-codec";
-       version = "0.1.0.3";
-       sha256 = "0kgkzskn2k9zgihrb1v9xy5yfjlggmpj15g1bdgx7faipksaa3fb";
+       version = "0.1.0.2";
+       sha256 = "07zf9lzin22clixmvgvam6h995jfq2wzqz4498qv60jlcj88zzmh";
        libraryHaskellDepends = [
          aeson base base64-bytestring binary bytestring scientific text
          unordered-containers vector
···
      }:
      mkDerivation {
        pname = "happstack-authenticate";
-       version = "2.4.1.1";
-       sha256 = "164pjybk054a3h3ydfakzibngpmp8a4cbzg0sip9slfb739nz25j";
+       version = "2.4.1";
+       sha256 = "1166ccqpjwr331chf7hi4n42m2frahpf93ardfjgv8x6d0p5pfss";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          acid-state aeson authenticate base base64-bytestring boomerang
···
        pname = "haskell-language-server";
        version = "0.9.0.0";
        sha256 = "0wzwadmrw57dqp9mszr4nmcnrwa01kav70z0wqkh8g2ag0kv3nfm";
-       revision = "3";
-       editedCabalFile = "02dvw9d9c7wja6y8q5ncjks5hjxjplnfn9jnw9cqzfyi97pv4cm6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "haskellish" = callPackage
     ({ mkDerivation, base, containers, haskell-src-exts, mtl
-     , template-haskell, text
+     , template-haskell
      }:
      mkDerivation {
        pname = "haskellish";
-       version = "0.2.4.2";
-       sha256 = "1d7rpb9l1ycmcr8ahxjb5p2v3qdlwnjdxkm292bnakvwazgnq7cw";
+       version = "0.2.3.1";
+       sha256 = "0285mk3s1gl0xxwcqd22v800pcg75ml676nzs5pb96ybfniqksl0";
        libraryHaskellDepends = [
-         base containers haskell-src-exts mtl template-haskell text
+         base containers haskell-src-exts mtl template-haskell
        ];
        description = "For parsing Haskell-ish languages";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.46.0";
-       sha256 = "18iig8wbbgknzgzjxicjhpbhp7a9wzq1nrvixfwf4gpdlxmzq18y";
+       version = "0.42.2";
+       sha256 = "03xys3m0cdkjbabcrgc96sdb8ws3rrzq794ggnkwigwzgnav0gm0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskoin-store-data";
-       version = "0.45.0";
-       sha256 = "1hzlc8w9xmbwsvz6j74pxbkxla9a0wdgill81vn8g3zk4r7z0xx5";
+       version = "0.42.1";
+       sha256 = "17yfbd4vp9xx551bybpkiiv6w1x8067xmyrfff7zak3glzb3piva";
        libraryHaskellDepends = [
          aeson base bytestring cereal containers data-default deepseq
          hashable haskoin-core http-client http-types lens mtl network
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "hie-bios_0_7_3" = callPackage
-    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
-     , conduit, conduit-extra, containers, cryptohash-sha1, deepseq
-     , directory, extra, file-embed, filepath, ghc, hslogger
-     , hspec-expectations, optparse-applicative, process, tasty
-     , tasty-expected-failure, tasty-hunit, temporary, text, time
-     , transformers, unix-compat, unordered-containers, vector, yaml
-     }:
-     mkDerivation {
-       pname = "hie-bios";
-       version = "0.7.3";
-       sha256 = "0njgxy8dx43smqk4wv3zg0c8a7llbgnz4fbil9dw53yx2xncgapi";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base base16-bytestring bytestring conduit conduit-extra
-         containers cryptohash-sha1 deepseq directory extra file-embed
-         filepath ghc hslogger process temporary text time transformers
-         unix-compat unordered-containers vector yaml
-       ];
-       executableHaskellDepends = [
-         base directory filepath ghc optparse-applicative
-       ];
-       testHaskellDepends = [
-         base directory extra filepath ghc hspec-expectations tasty
-         tasty-expected-failure tasty-hunit temporary text
-         unordered-containers yaml
-       ];
-       description = "Set up a GHC API session";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "hie-compat" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, directory
      , filepath, ghc, ghc-boot, transformers
···
 
   "hinit" = callPackage
     ({ mkDerivation, base, Cabal, containers, directory, exceptions
-     , fused-effects, Glob, haskeline, megaparsec, mustache, optics-core
-     , optparse-applicative, parser-combinators, path, path-io
+     , fused-effects, generic-lens, Glob, haskeline, lens, megaparsec
+     , mustache, optparse-applicative, parser-combinators, path, path-io
      , prettyprinter, prettyprinter-ansi-terminal, process
      , quickcheck-text, spdx-license, string-interpolate, text, time
      , tomland
      }:
      mkDerivation {
        pname = "hinit";
-       version = "0.2.1";
-       sha256 = "10lhx18g50f24l867kjqgb2qpky3vvx7w7s4sc3pidr3hc0ams3g";
+       version = "0.2.0";
+       sha256 = "1iklwj1kzv7nbb4bnrj0idfb0k26jjpw51mkbib73j4jpciah01v";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         base Cabal containers directory exceptions fused-effects Glob
-         haskeline megaparsec mustache optics-core optparse-applicative
-         parser-combinators path path-io prettyprinter
+         base Cabal containers directory exceptions fused-effects
+         generic-lens Glob haskeline lens megaparsec mustache
+         optparse-applicative parser-combinators path path-io prettyprinter
          prettyprinter-ansi-terminal process spdx-license string-interpolate
          text time tomland
        ];
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {};
-
-  "kdesrc-build-profiles" = callPackage
-  "kdesrc-build-profiles" = callPackage
-     mkDerivation {
-  "kdesrc-build-profiles" = callPackage
-       version = "0.1.0.0";
-  "kdesrc-build-profiles" = callPackage
-  "kdesrc-build-profiles" = callPackage
-  "kdesrc-build-profiles" = callPackage
-  "kdesrc-build-profiles" = callPackage
-       license = lib.licenses.bsd3;
      }) {};
 
   "kdesrc-build-profiles" = callPackage
···
        broken = true;
      }) {};
 
-  "ice40-prim" = callPackage
-    ({ mkDerivation, base, Cabal, clash-prelude, ghc-typelits-extra
-     , ghc-typelits-knownnat, ghc-typelits-natnormalise, interpolate
-     }:
-     mkDerivation {
-       pname = "ice40-prim";
-       version = "0.1.0.0";
-       sha256 = "00l0kwwayf0bark2yqjrx8imr8997d5mrnhjf3zsayxk9a521j99";
-       libraryHaskellDepends = [
-         base Cabal clash-prelude ghc-typelits-extra ghc-typelits-knownnat
-         ghc-typelits-natnormalise interpolate
-       ];
-       description = "Lattice iCE40 Primitive IP";
-       license = lib.licenses.bsd3;
-     }) {};
-
   "icepeak" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, containers
      , directory, hashable, hspec, hspec-core, hspec-expectations
···
        license = lib.licenses.mit;
      }) {};
 
-  "jira-wiki-markup_1_3_3" = callPackage
-    ({ mkDerivation, base, mtl, parsec, tasty, tasty-hunit, text }:
-     mkDerivation {
-       pname = "jira-wiki-markup";
-       version = "1.3.3";
-       sha256 = "0sgm9x2bdwazhj598aix2xyshjy6cvai4sgq5zz8gxv2l6prfbr7";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base mtl parsec text ];
-       executableHaskellDepends = [ base text ];
-       testHaskellDepends = [ base parsec tasty tasty-hunit text ];
-       description = "Handle Jira wiki markup";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "jmacro" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers
      , haskell-src-exts, haskell-src-meta, mtl, parseargs, parsec
···
      }:
      mkDerivation {
        pname = "kqueue";
-       version = "0.2.1";
-       sha256 = "0svrswcglipmm47lnqi41hcsn1gvkcniva6qajwqxrdr0wvvhgdi";
+       version = "0.2";
+       sha256 = "0sbkyq17i41kln7scrfc9kdzsbyb787z33kzpkdz2vrziapns33h";
+       revision = "3";
+       editedCabalFile = "17wanwn4pmh6z6v7ncg50q4sgg87lllld50wa5j5mmb07q4c3mj7";
        libraryHaskellDepends = [ base directory filepath mtl time unix ];
        libraryToolDepends = [ c2hs ];
        description = "A binding to the kqueue event library";
···
     ({ mkDerivation, base, bytestring, libtelnet }:
      mkDerivation {
        pname = "libtelnet";
-       version = "0.1.0.1";
-       sha256 = "13g7wpibjncj9h6yva8gj9fqs8j806r1vnina78wgv8f980dqxks";
+       version = "0.1.0.0";
+       sha256 = "0s2ldi4ikjdvki8r190mnkjd0jkahn8ln6gvqb8bn5d291j19nmc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
···
      }:
      mkDerivation {
        pname = "lsp";
-       version = "1.1.1.0";
-       sha256 = "04ndz4v1mwga13qndmnaaj145y5zqw7zv64px7ak26qvd1m26h9r";
+       version = "1.0.0.1";
+       sha256 = "1h7ymzzm00dnvbqxz4g0zp3mvm6v9bjbgkazz514wqrcmma27cm1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "lsp-test_0_13_0_0" = callPackage
+  "lsp-test_0_12_0_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async, base
      , bytestring, conduit, conduit-parse, containers, data-default
-     , Diff, directory, filepath, Glob, hspec, lens, lsp-types, mtl
-     , parser-combinators, process, some, text, time, transformers, unix
+     , Diff, directory, filepath, Glob, haskell-lsp, hspec, lens, mtl
+     , parser-combinators, process, text, transformers, unix
      , unordered-containers
      }:
      mkDerivation {
        pname = "lsp-test";
-       version = "0.13.0.0";
-       sha256 = "1xyxmzcd6r56jj1k11lz1g6yld5q3k6cgb0bsf45px120dsf1dpy";
+       version = "0.12.0.0";
+       sha256 = "1zc43j7xyfxv2i9vinx82yhkrr6m4gz46jwn9p39k76ld6j8nzpd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty ansi-terminal async base bytestring conduit
          conduit-parse containers data-default Diff directory filepath Glob
-         lens lsp-types mtl parser-combinators process some text time
-         transformers unix unordered-containers
+         haskell-lsp lens mtl parser-combinators process text transformers
+         unix unordered-containers
        ];
        testHaskellDepends = [
-         aeson base data-default directory filepath hspec lens lsp-types
+         aeson base data-default directory filepath haskell-lsp hspec lens
          text unordered-containers
        ];
        description = "Functional test framework for LSP servers";
···
 
   "lsp-types" = callPackage
     ({ mkDerivation, aeson, base, binary, bytestring, containers
-     , data-default, deepseq, dependent-sum, dependent-sum-template
-     , directory, filepath, hashable, hslogger, lens, network-uri
-     , rope-utf16-splay, scientific, some, template-haskell, temporary
-     , text, unordered-containers
+     , data-default, deepseq, dependent-sum-template, directory
+     , filepath, hashable, hslogger, lens, network-uri, rope-utf16-splay
+     , scientific, some, template-haskell, temporary, text
+     , unordered-containers
      }:
      mkDerivation {
        pname = "lsp-types";
-       version = "1.1.0.0";
-       sha256 = "19lkdqwh9a5rsx5nby37v54zhwyja306z0dyslsmdmwqw92qxx54";
+       version = "1.0.0.1";
+       sha256 = "1yrm42qsbqk94ql0khifcpvicy9lbvwwrvnr41lplbb1vhqvqc27";
        libraryHaskellDepends = [
          aeson base binary bytestring containers data-default deepseq
-         dependent-sum dependent-sum-template directory filepath hashable
-         hslogger lens network-uri rope-utf16-splay scientific some
-         template-haskell temporary text unordered-containers
+         dependent-sum-template directory filepath hashable hslogger lens
+         network-uri rope-utf16-splay scientific some template-haskell
+         temporary text unordered-containers
        ];
        description = "Haskell library for the Microsoft Language Server Protocol, data types";
        license = lib.licenses.mit;
···
      }) {};
 
   "mmsyn7l" = callPackage
-    ({ mkDerivation, base, directory, mmsyn2-array, mmsyn3
-     , mmsyn7ukr-common, process
+    ({ mkDerivation, base, directory, mmsyn2, mmsyn3, mmsyn7ukr
+     , process, vector
      }:
      mkDerivation {
        pname = "mmsyn7l";
-       version = "0.9.0.0";
-       sha256 = "0j8xi8jxak818sw310srxljrywggsa8ss1l4yw0razsa28h92nxq";
+       version = "0.8.0.0";
+       sha256 = "0w1k89phzxyq2nwzr0vn313rlp0f7d62vhdvq113pqszbdbjh6gd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base directory mmsyn2-array mmsyn3 mmsyn7ukr-common process
+         base directory mmsyn2 mmsyn3 mmsyn7ukr process vector
        ];
        executableHaskellDepends = [
-         base directory mmsyn2-array mmsyn3 mmsyn7ukr-common process
+         base directory mmsyn2 mmsyn3 mmsyn7ukr process vector
        ];
        description = "Modifies the amplitudes of the Ukrainian sounds representations created by mmsyn7ukr package";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "modern-uri_0_3_4_0" = callPackage
-    ({ mkDerivation, base, bytestring, containers, contravariant
-     , criterion, deepseq, exceptions, hspec, hspec-discover
-     , hspec-megaparsec, megaparsec, mtl, profunctors, QuickCheck
-     , reflection, tagged, template-haskell, text, weigh
-     }:
-     mkDerivation {
-       pname = "modern-uri";
-       version = "0.3.4.0";
-       sha256 = "1jb1bj2jgxhhvkc50h1c11c3zd66bpbi67b1h6b8773h0yiqffvk";
-       libraryHaskellDepends = [
-         base bytestring containers contravariant deepseq exceptions
-         megaparsec mtl profunctors QuickCheck reflection tagged
-         template-haskell text
-       ];
-       testHaskellDepends = [
-         base bytestring hspec hspec-megaparsec megaparsec QuickCheck text
-       ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion deepseq megaparsec text weigh
-       ];
-       description = "Modern library for working with URIs";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "modify-fasta" = callPackage
     ({ mkDerivation, base, containers, fasta, mtl, optparse-applicative
      , pipes, pipes-text, regex-tdfa, regex-tdfa-text, semigroups, split
···
      }:
      mkDerivation {
        pname = "mu-rpc";
-       version = "0.5.0.1";
-       sha256 = "0r5kbi378iwg5b578dydvv4smy2xqn4y33h015fp5nyphxz83173";
+       version = "0.5.0.0";
+       sha256 = "15a950ig348h0fxfvzq4pj8s8rryn18cd26vmrcmx7s6w32zlzyr";
        libraryHaskellDepends = [
          aeson base conduit http-types mtl mu-schema sop-core
          template-haskell text wai
···
        pname = "mwc-random";
        version = "0.15.0.1";
        sha256 = "1p8c5g4hb72k90ai39rgpn6cr942i6636l1y0zfp9xgjb3v0a2q3";
-       revision = "1";
-       editedCabalFile = "1ay26mvzxqw6rzw3hkib1j12gk6fa2hsilz12q8vhp646bqqc744";
        libraryHaskellDepends = [
          base math-functions primitive random time vector
        ];
···
        ];
        description = "An MQTT Protocol Implementation";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "net-mqtt-lens" = callPackage
···
        ];
        description = "Optics for net-mqtt";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "net-mqtt-rpc" = callPackage
···
        ];
        description = "Make RPC calls via an MQTT broker";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "net-spider" = callPackage
···
        pname = "network-byte-order";
        version = "0.1.6";
        sha256 = "0pnwcg13k4qw82n0zc1xibyc24sc77y79j5a62pqdmjrnz4wrc7j";
-       revision = "1";
-       editedCabalFile = "0fpyfd1adg9fr7w6afxkx306c0kaz3ji3x78sl29v9j3mh4vdn13";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [ base bytestring doctest ];
        description = "Network byte order utilities";
···
        pname = "perfect-vector-shuffle";
        version = "0.1.1.1";
        sha256 = "1z4iv4sv9ld0gvdfa46ll5bsbxi9lckh69paip1c5ijcg78vy5y0";
-       revision = "5";
-       editedCabalFile = "0lppvhpfpfzcpdm4fxmsps8s272gz3wd2h5xc1w1908b7qqln0rw";
+       revision = "4";
+       editedCabalFile = "14q0773vxmkh4nwskiq85ch175jq12xms2lypaddglciykqs6ml6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-base";
-       version = "0.2.0.0";
-       sha256 = "1382i77ci70ax7lvbkqqvg1wr2pp5irl8wxvypngr15czqgj7sca";
+       version = "0.1.0.0";
+       sha256 = "0fd2pslmgm5bvv0yiza87vp61601pl1c69xa5snbgrnb2mlp6f98";
        libraryHaskellDepends = [
          base phonetic-languages-permutations-array subG
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "pipes-bytestring_2_1_7" = callPackage
-    ({ mkDerivation, base, bytestring, pipes, pipes-group, pipes-parse
-     , stringsearch, transformers
-     }:
-     mkDerivation {
-       pname = "pipes-bytestring";
-       version = "2.1.7";
-       sha256 = "0ch7145pv4f56601ysdj5gqqwsh5ag2zh34ydswg62fqi8z8cxvc";
-       libraryHaskellDepends = [
-         base bytestring pipes pipes-group pipes-parse stringsearch
-         transformers
-       ];
-       description = "ByteString support for pipes";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "pipes-bzip" = callPackage
     ({ mkDerivation, base, bindings-DSL, bytestring, bzip2, bzlib
      , data-default, directory, hspec, MonadRandom, mtl, pipes
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "pipes-parse_3_0_9" = callPackage
-    ({ mkDerivation, base, pipes, transformers }:
-     mkDerivation {
-       pname = "pipes-parse";
-       version = "3.0.9";
-       sha256 = "05cd0j1avkzmryf3869hfpvd9xmzbpz4kc65srswx36n06dkz5x3";
-       libraryHaskellDepends = [ base pipes transformers ];
-       description = "Parsing infrastructure for the pipes ecosystem";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "pipes-postgresql-simple" = callPackage
     ({ mkDerivation, async, base, bytestring, exceptions, mtl, pipes
      , pipes-concurrency, pipes-safe, postgresql-simple, stm, text
···
        ];
        description = "Safety for the pipes ecosystem";
        license = lib.licenses.bsd3;
-     }) {};
-
-  "pipes-safe_2_3_3" = callPackage
-    ({ mkDerivation, base, containers, exceptions, monad-control, mtl
-     , pipes, primitive, transformers, transformers-base
-     }:
-     mkDerivation {
-       pname = "pipes-safe";
-       version = "2.3.3";
-       sha256 = "19gp93x5m1bnq240bj3v33pglf9r5gzji39fsjcazji837czghab";
-       libraryHaskellDepends = [
-         base containers exceptions monad-control mtl pipes primitive
-         transformers transformers-base
-       ];
-       description = "Safety for the pipes ecosystem";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pipes-shell" = callPackage
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {};
-
-  "pixel-printer" = callPackage
-    ({ mkDerivation, base, JuicyPixels, lens }:
-     mkDerivation {
-       pname = "pixel-printer";
-       version = "0.1.0";
-       sha256 = "1cx485lvd5z6895jv1iiq93kspch78w9m730ggw6nvf0rimvazyy";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base JuicyPixels lens ];
-       executableHaskellDepends = [ base JuicyPixels ];
-       testHaskellDepends = [ base ];
-       description = "A program for turning pixel art into 3D prints";
-       license = lib.licenses.gpl3;
      }) {};
 
   "pixela" = callPackage
···
        pname = "random";
        version = "1.2.0";
        sha256 = "1pmr7zbbqg58kihhhwj8figf5jdchhi7ik2apsyxbgsqq3vrqlg4";
-       revision = "5";
-       editedCabalFile = "1jai1pcs39ijdhxc8q36x1yayr8rsblhx3y88paf4bqxrks2vmrh";
+       revision = "4";
+       editedCabalFile = "08mq836ganl3sq6mfn3hrj6xm0h30klp21y7gbd9md2882agndrk";
        libraryHaskellDepends = [ base bytestring deepseq mtl splitmix ];
        testHaskellDepends = [
          base bytestring containers doctest mwc-random primitive smallcheck
···
        ];
        description = "Efficient generation of random bytestrings";
        license = lib.licenses.mit;
-     }) {};
-
-  "random-bytestring_0_1_4" = callPackage
-    ({ mkDerivation, async, base, bytestring, criterion, cryptonite
-     , entropy, ghc-prim, mwc-random, pcg-random, primitive, random
-     }:
-     mkDerivation {
-       pname = "random-bytestring";
-       version = "0.1.4";
-       sha256 = "0f4n41gqxxggadysvx3vg2iq89z7i7692ccrfmiajq73lbp6y34j";
-       libraryHaskellDepends = [ base bytestring mwc-random pcg-random ];
-       benchmarkHaskellDepends = [
-         async base bytestring criterion cryptonite entropy ghc-prim
-         mwc-random pcg-random primitive random
-       ];
-       description = "Efficient generation of random bytestrings";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "random-class" = callPackage
···
      }:
      mkDerivation {
        pname = "rhbzquery";
-       version = "0.4.3";
-       sha256 = "13brargymd1c9b0csaprj85qdqg98bzj3z2smbb0v66myj48v6fp";
+       version = "0.4.2";
+       sha256 = "1j9nxizi1wsgz5gamdn9izy4aq6ci41gbkvsw7bbpc8fnvv5gpd2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      , containers, crackNum, deepseq, directory, doctest, filepath
      , gauge, Glob, hlint, mtl, pretty, process, QuickCheck, random
      , silently, syb, tasty, tasty-golden, tasty-hunit, tasty-quickcheck
-     , template-haskell, text, time, transformers, uniplate, z3
+     , template-haskell, time, transformers, uniplate, z3
      }:
      mkDerivation {
        pname = "sbv";
-       version = "8.10";
-       sha256 = "1j9hy840dl78rr1ixhlz24wwymbpiv46hpz8i6dd0gngrfha09ji";
+       version = "8.9";
+       sha256 = "1h8bhi1pjlg0v16wwqcvil7gq98b6dn8ckzmrsgb8sc3qz0nxj51";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array async base containers crackNum deepseq directory filepath mtl
-         pretty process QuickCheck random syb template-haskell text time
+         pretty process QuickCheck random syb template-haskell time
          transformers uniplate
        ];
        testHaskellDepends = [
···
        testSystemDepends = [ z3 ];
        benchmarkHaskellDepends = [
          base bench-show containers crackNum deepseq directory filepath
-         gauge mtl process random silently syb text time
+         gauge mtl process random silently syb time
        ];
        description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.mit;
      }) {};
 
-  "serversession_1_0_2" = callPackage
-    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
-     , containers, data-default, hashable, hspec, nonce, path-pieces
-     , persistent-test, QuickCheck, text, time, transformers
-     , unordered-containers
-     }:
-     mkDerivation {
-       pname = "serversession";
-       version = "1.0.2";
-       sha256 = "02ynhgq6gn5ddx2yd8ns8ay0rrhzln2h6jrmnwk7x1fqqfvzx0jf";
-       libraryHaskellDepends = [
-         aeson base base64-bytestring bytestring data-default hashable nonce
-         path-pieces persistent-test text time transformers
-         unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson base base64-bytestring bytestring containers data-default
-         hspec nonce path-pieces QuickCheck text time transformers
-         unordered-containers
-       ];
-       description = "Secure, modular server-side sessions";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "serversession-backend-acid-state" = callPackage
     ({ mkDerivation, acid-state, base, containers, hspec, mtl, safecopy
      , serversession, unordered-containers
      }:
      mkDerivation {
        pname = "serversession-backend-acid-state";
-       version = "1.0.4";
-       sha256 = "1mchxnkrpa6grp8h5iji40fyhya2lvb433yby4iymaaakzgjs19z";
+       version = "1.0.3";
+       sha256 = "1rkw5an7lwx05063caqjhvf449jxij2zrbymg64p600mngb1flq0";
        libraryHaskellDepends = [
          acid-state base containers mtl safecopy serversession
          unordered-containers
···
      }:
      mkDerivation {
        pname = "serversession-backend-persistent";
-       version = "1.0.5";
-       sha256 = "1mcaqafyr5x0v475j7rs2z4059jggzfj8rky66ls0mlvd9br91s0";
+       version = "1.0.4";
+       sha256 = "074pxfv1yj6ffxp4bg0ia20w7ikdja3g3k1l93nnjcni13zddwn7";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring cereal path-pieces
          persistent serversession tagged text time transformers
···
      }:
      mkDerivation {
        pname = "serversession-backend-redis";
-       version = "1.0.4";
-       sha256 = "1rrz2p103271pyhdlbwim8vz91yl1qip0lagf74d277x74v9hyp5";
+       version = "1.0.3";
+       sha256 = "059nak15x4cbwmfbvfih6ndwa6i5jhcba22h9gz44f6s84vhljyf";
        libraryHaskellDepends = [
          base bytestring hedis path-pieces serversession tagged text time
          transformers unordered-containers
···
      }:
      mkDerivation {
        pname = "signable";
-       version = "0.3";
-       sha256 = "1bh4i93333s3yldn4nnl4xv4gb92ggdwap6im9f259cfg1v22d2q";
+       version = "0.2";
+       sha256 = "1p1g6jhxgskl890g84nw8d465pan9d3prbc4jvyn8502bx00w01s";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base binary bytestring casing cryptonite
          memory microlens pem proto-lens proto-lens-runtime
···
        pname = "streamproc";
        version = "1.6.2";
        sha256 = "1wl44n4nav4h203mzfdf1bd5nh4v23dib54lvxka1rl3zymgyvp7";
-       revision = "2";
-       editedCabalFile = "1j3frdzhlvmggqq07b7kiz6h7mim64n2frsb2d3hzsjd7jym526j";
+       revision = "1";
+       editedCabalFile = "19c51gks028x8mnywkx1nz0s6bwn2mxs5ddmaj2q8n9l5pvfkcgs";
        libraryHaskellDepends = [ base ];
        description = "Stream Processer Arrow";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "string-interpolate_0_3_1_0" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, deepseq, formatting
-     , haskell-src-exts, haskell-src-meta, hspec, hspec-core
-     , interpolate, neat-interpolation, QuickCheck, quickcheck-instances
-     , quickcheck-text, quickcheck-unicode, split, template-haskell
-     , text, text-conversions, unordered-containers, utf8-string
-     }:
-     mkDerivation {
-       pname = "string-interpolate";
-       version = "0.3.1.0";
-       sha256 = "0hyrcndhwd06phlmykyz7bklj5gnj4amcn11ckfvw0iws3sksl8d";
-       libraryHaskellDepends = [
-         base bytestring haskell-src-exts haskell-src-meta split
-         template-haskell text text-conversions utf8-string
-       ];
-       testHaskellDepends = [
-         base bytestring hspec hspec-core QuickCheck quickcheck-instances
-         quickcheck-text quickcheck-unicode template-haskell text
-         unordered-containers
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion deepseq formatting interpolate
-         neat-interpolation QuickCheck text
-       ];
-       description = "Haskell string/text/bytestring interpolation that just works";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "string-isos" = callPackage
     ({ mkDerivation, base, bytestring, mono-traversable, safe, text
      , type-iso
···
        license = lib.licenses.gpl2;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {};
-
-  "swisstable" = callPackage
-    ({ mkDerivation, base, criterion, deepseq, hashable, hashtables
-     , primitive, QuickCheck, tasty, tasty-discover, tasty-hunit, vector
-     }:
-     mkDerivation {
-       pname = "swisstable";
-       version = "0.1.0.2";
-       sha256 = "0zffsavnxnwhzxgbwpqg38gnjywgfdk60hbg0wvpggk1zaw0ylr1";
-       libraryHaskellDepends = [ base hashable primitive vector ];
-       testHaskellDepends = [
-         base hashable primitive QuickCheck tasty tasty-discover tasty-hunit
-         vector
-       ];
-       testToolDepends = [ tasty-discover ];
-       benchmarkHaskellDepends = [
-         base criterion deepseq hashable hashtables primitive QuickCheck
-         vector
-       ];
-       description = "SwissTable hash map";
-       license = lib.licenses.bsd3;
      }) {};
 
   "sws" = callPackage
···
        pname = "these";
        version = "1.1.1.1";
        sha256 = "027m1gd7i6jf2ppfkld9qrv3xnxg276587pmx10z9phpdvswk66p";
-       revision = "1";
-       editedCabalFile = "1bzi28jvaxil9rc6z1hkf87pfjsa3r5gfc9n0ixffnnv519cd0g9";
        libraryHaskellDepends = [ assoc base binary deepseq hashable ];
        description = "An either-or-both data type";
        license = lib.licenses.bsd3;
···
        pname = "time-compat";
        version = "1.9.5";
        sha256 = "19p3056i6kh8lgcdsnwsh8pj80xyi23kmw9n7hmdacczs5kv49ii";
-       revision = "1";
-       editedCabalFile = "1f6r8cyfgzpfg9nrsqbf99pi44fyds9wcmgwxb4s0zmlb5dbv1m5";
        libraryHaskellDepends = [ base base-orphans deepseq time ];
        testHaskellDepends = [
          base base-compat deepseq HUnit QuickCheck tagged tasty tasty-hunit
···
        ];
        description = "Bidirectional TOML serialization";
        license = lib.licenses.mpl20;
-     }) {};
-
-  "tomland_1_3_2_0" = callPackage
-    ({ mkDerivation, base, bytestring, containers, deepseq, directory
-     , hashable, hedgehog, hspec, hspec-golden, hspec-hedgehog
-     , hspec-megaparsec, markdown-unlit, megaparsec, mtl
-     , parser-combinators, text, time, transformers
-     , unordered-containers, validation-selective
-     }:
-     mkDerivation {
-       pname = "tomland";
-       version = "1.3.2.0";
-       sha256 = "0yj39mh4z3v3jqri38s3ylrglv657g3m7gqr2rz8ydlvx2draknc";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring containers deepseq hashable megaparsec mtl
-         parser-combinators text time transformers unordered-containers
-         validation-selective
-       ];
-       executableHaskellDepends = [
-         base bytestring containers hashable text time unordered-containers
-       ];
-       executableToolDepends = [ markdown-unlit ];
-       testHaskellDepends = [
-         base bytestring containers directory hashable hedgehog hspec
-         hspec-golden hspec-hedgehog hspec-megaparsec megaparsec text time
-         unordered-containers
-       ];
-       description = "Bidirectional TOML serialization";
-       license = lib.licenses.mpl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tomlcheck" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ua-parser_0_7_6_0" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, criterion, data-default
-     , deepseq, file-embed, filepath, HUnit, pcre-light, tasty
-     , tasty-hunit, tasty-quickcheck, text, yaml
-     }:
-     mkDerivation {
-       pname = "ua-parser";
-       version = "0.7.6.0";
-       sha256 = "0sakvmmf6p2ca0dbkwqdj5cv93gp78srw0zc4f1skcgndkmxwk6l";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         aeson base bytestring data-default file-embed pcre-light text yaml
-       ];
-       testHaskellDepends = [
-         aeson base bytestring data-default file-embed filepath HUnit
-         pcre-light tasty tasty-hunit tasty-quickcheck text yaml
-       ];
-       benchmarkHaskellDepends = [
-         aeson base bytestring criterion data-default deepseq file-embed
-         filepath pcre-light text yaml
-       ];
-       description = "A library for parsing User-Agent strings, official Haskell port of ua-parser";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "uacpid" = callPackage
     ({ mkDerivation, base, containers, directory, filepath, hslogger
      , mtl, network, process, regex-compat, time, time-locale-compat
···
        pname = "uuid";
        version = "1.3.13";
        sha256 = "09xhk42yhxvqmka0iqrv3338asncz8cap3j0ic0ps896f2581b6z";
-       revision = "5";
-       editedCabalFile = "0hv9xrs6n005cid9laxbimyg5cxywvcd0fh8pyadqqvk3b8zlj9d";
+       revision = "3";
+       editedCabalFile = "1p2srrapgx1f3zkdjjzm5g0dyfpg1h2g056la85xmpyjs77la2rq";
        libraryHaskellDepends = [
          base binary bytestring cryptohash-md5 cryptohash-sha1 entropy
          network-info random text time uuid-types
···
        pname = "uuid-types";
        version = "1.0.3";
        sha256 = "1zdka5jnm1h6k36w3nr647yf3b5lqb336g3fkprhd6san9x52xlj";
-       revision = "4";
-       editedCabalFile = "0ipwfd5y8021ygpadjjhchw5irm0x27dlv1k2hf4znza5v7hadcn";
+       revision = "3";
+       editedCabalFile = "0znx08r25sgs5j7ix8i9aikhgad0kc9i6vgkg0g3jzxk5haal9sf";
        libraryHaskellDepends = [
          base binary bytestring deepseq hashable random text
        ];
···
      }:
      mkDerivation {
        pname = "vega-view";
-       version = "0.3.1.7";
-       sha256 = "1181gfxyxf2m3m23xg89kmmp8aizrm9sm908ydbkw885idh2k5x0";
+       version = "0.3.1.6";
+       sha256 = "0s9d3g47qnzcpi2p1z60axrr53jbc6q4qyma88qxsrf6ava115ar";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) libdevil;};
-
-  "yasi" = callPackage
-    ({ mkDerivation, base, bytestring, hedgehog, tasty, tasty-discover
-     , tasty-hedgehog, tasty-hunit, template-haskell, text
-     }:
-     mkDerivation {
-       pname = "yasi";
-       version = "0.1.1.1";
-       sha256 = "0b3ajgxf8bk2pjfwqmf748x1yzyq9knjsya2xzkdrjs5vffg1j9k";
-       libraryHaskellDepends = [ base bytestring template-haskell text ];
-       testHaskellDepends = [
-         base hedgehog tasty tasty-hedgehog tasty-hunit text
-       ];
-       testToolDepends = [ tasty-discover ];
-       description = "Yet another string interpolator";
-       license = lib.licenses.cc0;
-     }) {};
 
   "yate" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, hspec, mtl, scientific

pkgs/development/interpreters/janet/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "janet";
-  version = "1.15.0";
+  version = "1.15.2";
 
   src = fetchFromGitHub {
     owner = "janet-lang";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-NLPmuS7HTPY8OfeppqVhrj4iVZix4orr1oYilcXaAqI=";
+    sha256 = "sha256-xIvcHMDBPdmNSp0/aaVDXxCmCpQOtSFG99lyHAWmbY0=";
   };
 
   nativeBuildInputs = [ meson ninja ];

pkgs/development/interpreters/quickjs/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "quickjs";
-  version = "2019-12-21";
+  version = "2020-11-08";
 
   src = fetchurl {
     url = "https://bellard.org/${pname}/${pname}-${version}.tar.xz";
-    sha256 = "13hlx6qwrrxmlvvqcr3irxba6zmf05cf54l32vj50wc66s1qd41p";
+    sha256 = "0yqqcjxi3cqagw184mqrxpvqg486x7c233r3cp9mxachngd6779f";
   };
 
   makeFlags = [ "prefix=${placeholder "out"}" ];
···
     # Programs exit with code 1 when testing help, so grep for a string
     set +o pipefail
     qjs     --help 2>&1 | grep "QuickJS version"
-    qjsbn   --help 2>&1 | grep "QuickJS version"
     qjscalc --help 2>&1 | grep "QuickJS version"
     set -o pipefail
 
···
     echo "console.log('Output from compiled program');" > "$temp"
     set -o verbose
     out=$(mktemp) && qjsc         "$temp" -o "$out" && "$out" | grep -q "Output from compiled program"
-    out=$(mktemp) && qjsbnc       "$temp" -o "$out" && "$out" | grep -q "Output from compiled program"
     out=$(mktemp) && qjsc   -flto "$temp" -o "$out" && "$out" | grep -q "Output from compiled program"
-    out=$(mktemp) && qjsbnc -flto "$temp" -o "$out" && "$out" | grep -q "Output from compiled program"
   '';
 
   meta = with lib; {

pkgs/development/libraries/science/math/cudnn/default.nix

···
-{ callPackage, cudatoolkit_7, cudatoolkit_7_5, cudatoolkit_8, cudatoolkit_9_0, cudatoolkit_9_1, cudatoolkit_9_2, cudatoolkit_10_0, cudatoolkit_10_1, cudatoolkit_10_2, cudatoolkit_11_0, cudatoolkit_11_1, cudatoolkit_11_2 }:
+{ callPackage, cudatoolkit_9_0, cudatoolkit_9_1, cudatoolkit_9_2, cudatoolkit_10_0, cudatoolkit_10_1, cudatoolkit_10_2, cudatoolkit_11_0, cudatoolkit_11_1, cudatoolkit_11_2 }:
 
 let
   generic = args: callPackage (import ./generic.nix (removeAttrs args ["cudatoolkit"])) {
···
   };
 
 in rec {
-  cudnn_cudatoolkit_7 = generic rec {
-    # Old URL is v4 instead of v4.0 for some reason...
-    version = "4";
-    cudatoolkit = cudatoolkit_7;
-    srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v4.0-prod.tgz";
-    sha256 = "01a4v5j4v9n2xjqcc4m28c3m67qrvsx87npvy7zhx7w8smiif2fd";
-  };
-
-  cudnn_cudatoolkit_7_5 = generic rec {
-    version = "6.0";
-    cudatoolkit = cudatoolkit_7_5;
-    srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v${version}.tgz";
-    sha256 = "0b68hv8pqcvh7z8xlgm4cxr9rfbjs0yvg1xj2n5ap4az1h3lp3an";
-  };
-
-  cudnn6_cudatoolkit_8 = generic rec {
-    version = "6.0";
-    cudatoolkit = cudatoolkit_8;
-    srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v${version}.tgz";
-    sha256 = "173zpgrk55ri8if7s5yngsc89ajd6hz4pss4cdxlv6lcyh5122cv";
-  };
-
-  cudnn_cudatoolkit_8 = generic rec {
-    version = "7.0.5";
-    cudatoolkit = cudatoolkit_8;
-    srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.tgz";
-    sha256 = "9e0b31735918fe33a79c4b3e612143d33f48f61c095a3b993023cdab46f6d66e";
-  };
-
   cudnn_cudatoolkit_9_0 = generic rec {
     version = "7.3.0";
     cudatoolkit = cudatoolkit_9_0;

pkgs/development/node-packages/generate.sh

···
 set -eu -o pipefail
 
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-node2nix=$(nix-build ../../.. --no-out-link -A nodePackages.node2nix)
-
+node2nix=$(nix-build ../../.. -A nodePackages.node2nix)
 cd ${DIR}
 rm -f ./node-env.nix
 ${node2nix}/bin/node2nix -i node-packages.json -o node-packages.nix -c composition.nix
+# using --no-out-link in nix-build argument would cause the
+# gc to run before the script finishes
+# which would cause a failure
+# it's safer to just remove the link after the script finishes
+# see https://github.com/NixOS/nixpkgs/issues/112846 for more details
+rm ./result

pkgs/development/ocaml-modules/carton/default.nix

···
+{ lib, buildDunePackage, fetchurl
+, ke, duff, decompress, cstruct, optint, bigstringaf, stdlib-shims
+, bigarray-compat, checkseum, logs, psq, fmt
+, result, rresult, fpath, base64, bos, digestif, mmap, alcotest
+, crowbar, alcotest-lwt, lwt, findlib, mirage-flow, cmdliner
+}:
+
+buildDunePackage rec {
+  pname = "carton";
+  version = "0.2.0";
+
+  useDune2 = true;
+  minimumOCamlVersion = "4.08";
+
+  src = fetchurl {
+    url = "https://github.com/mirage/ocaml-git/releases/download/${pname}-v${version}/${pname}-${pname}-v${version}.tbz";
+    sha256 = "0gfns4a9p9540kijccsg52yzyn3jfvi737mb0g71yazyc89dqwhn";
+  };
+
+  # remove changelogs for mimic and the git* packages
+  postPatch = ''
+    rm CHANGES.md CHANGES.mimic.md
+  '';
+
+  buildInputs = [
+    cmdliner
+    digestif
+    mmap
+    result
+    rresult
+    fpath
+    bos
+  ];
+  propagatedBuildInputs = [
+    ke
+    duff
+    decompress
+    cstruct
+    optint
+    bigstringaf
+    stdlib-shims
+    bigarray-compat
+    checkseum
+    logs
+    psq
+    fmt
+  ];
+
+  doCheck = true;
+  checkInputs = [
+    base64
+    alcotest
+    alcotest-lwt
+    crowbar
+    lwt
+    findlib
+    mirage-flow
+  ];
+
+  meta = with lib; {
+    description = "Implementation of PACKv2 file in OCaml";
+    license = licenses.mit;
+    homepage = "https://github.com/mirage/ocaml-git";
+    maintainers = [ maintainers.sternenseemann ];
+  };
+}

pkgs/development/ocaml-modules/carton/git.nix

···
+{ buildDunePackage, carton, carton-lwt
+, bigarray-compat, bigstringaf, lwt, fpath, result
+, mmap, fmt, decompress, astring
+, alcotest, alcotest-lwt, cstruct, logs
+, mirage-flow, rresult, ke
+}:
+
+buildDunePackage {
+  pname = "carton-git";
+
+  inherit (carton) version src useDune2 minimumOCamlVersion postPatch;
+
+  propagatedBuildInputs = [
+    carton
+    carton-lwt
+    bigarray-compat
+    bigstringaf
+    lwt
+    fpath
+    result
+    mmap
+    fmt
+    decompress
+    astring
+  ];
+
+  inherit (carton) meta;
+}

pkgs/development/ocaml-modules/carton/lwt.nix

···
+{ buildDunePackage, carton
+, lwt, decompress, optint, bigstringaf
+, alcotest, alcotest-lwt, cstruct, fmt, logs
+, mirage-flow, result, rresult, bigarray-compat
+, ke, base64, bos, checkseum, digestif, fpath, mmap
+, stdlib-shims
+, git-binary # pkgs.git
+}:
+
+buildDunePackage {
+  pname = "carton-lwt";
+
+  inherit (carton) version src useDune2 minimumOCamlVersion postPatch;
+
+  propagatedBuildInputs = [
+    carton
+    lwt
+    decompress
+    optint
+    bigstringaf
+  ];
+
+  doCheck = true;
+  checkInputs = [
+    git-binary
+    alcotest
+    alcotest-lwt
+    cstruct
+    fmt
+    logs
+    mirage-flow
+    result
+    rresult
+    bigarray-compat
+    ke
+    base64
+    bos
+    checkseum
+    digestif
+    fpath
+    mmap
+    stdlib-shims
+  ];
+
+  inherit (carton) meta;
+}

pkgs/development/ocaml-modules/decompress/default.nix

···
 { lib, fetchurl, buildDunePackage
-, checkseum, cmdliner
-, alcotest, bos, camlzip, mmap, re
+, checkseum, bigarray-compat, optint
+, bigstringaf, alcotest, hxd, camlzip, base64
 }:
 
 buildDunePackage rec {
-  version = "0.9.0";
+  version = "1.2.0";
   pname = "decompress";
+
+  minimumOCamlVersion = "4.07";
 
   useDune2 = true;
 
   src = fetchurl {
     url = "https://github.com/mirage/decompress/releases/download/v${version}/decompress-v${version}.tbz";
-    sha256 = "0fryhcvv96vfca51c7kqdn3n3canqsbbvfbi75ya6lca4lmpipbh";
+    sha256 = "1c3sq9a6kpzl0pj3gmg7w18ssjjl70yv0r3l7qjprcncjx23v62i";
   };
 
-  buildInputs = [ cmdliner ];
-  propagatedBuildInputs = [ checkseum ];
-  checkInputs = lib.optionals doCheck [ alcotest bos camlzip mmap re ];
+  propagatedBuildInputs = [ optint bigarray-compat checkseum ];
+  checkInputs = [ alcotest bigstringaf hxd camlzip base64 ];
   doCheck = true;
 
   meta = {

pkgs/development/ocaml-modules/duff/default.nix

···
 { lib, fetchurl, buildDunePackage
-, cstruct, fmt
-, bos, cmdliner, fpath, logs
-, alcotest
+, stdlib-shims, bigarray-compat, fmt
+, alcotest, hxd, crowbar, bigstringaf
 }:
 
 buildDunePackage rec {
   pname = "duff";
-  version = "0.2";
+  version = "0.3";
 
   useDune2 = true;
 
   src = fetchurl {
     url = "https://github.com/mirage/duff/releases/download/v${version}/duff-v${version}.tbz";
-    sha256 = "0bi081w4349cqc1n9jsjh1lrcqlnv3nycmvh9fniscv8lz1c0gjq";
+    sha256 = "1lb67yxk93ifj94p1i3swjbnj5xy8j6xzs72bwvq6cffx5xykznm";
   };
 
-  buildInputs = [ bos cmdliner fpath logs ] ++ lib.optional doCheck alcotest;
-  propagatedBuildInputs = [ cstruct fmt ];
+  propagatedBuildInputs = [ stdlib-shims bigarray-compat fmt ];
 
   doCheck = true;
+  checkInputs = [
+    alcotest
+    crowbar
+    hxd
+    bigstringaf
+  ];
+
 
   meta = {
     description = "Pure OCaml implementation of libXdiff (Rabin’s fingerprint)";

pkgs/development/ocaml-modules/encore/default.nix

···
 { lib, buildDunePackage, fetchurl, ocaml
-, fmt, bigstringaf, bigarray-compat
-, bigarray-overlap, angstrom, ke, alcotest }:
+, fmt, bigstringaf, angstrom, alcotest }:
 
 buildDunePackage rec {
   pname = "encore";
-  version = "0.5";
+  version = "0.7";
+
+  minimumOCamlVersion = "4.07";
 
   src = fetchurl {
     url = "https://github.com/mirage/encore/releases/download/v${version}/encore-v${version}.tbz";
-    sha256 = "15n0dla149k9h7migs76wap08z5402qcvxyqxzl887ha6isj3p9n";
+    sha256 = "0cwmhkj5jmk3z5y0agmkf5ygpgxynjkq2d7d50jgzmnqs7f6g7nh";
   };
 
   useDune2 = true;
 
-  propagatedBuildInputs = [ angstrom ke fmt bigstringaf bigarray-compat bigarray-overlap ];
+  propagatedBuildInputs = [ angstrom fmt bigstringaf ];
   checkInputs = [ alcotest ];
   doCheck = true;
 

pkgs/development/ocaml-modules/git-http/default.nix

···
-{ buildDunePackage, git, cohttp, cohttp-lwt }:
-
-buildDunePackage {
-  pname = "git-http";
-  inherit (git) version src minimumOCamlVersion;
-
-  useDune2 = true;
-
-  propagatedBuildInputs = [ git cohttp cohttp-lwt ];
-
-  meta = {
-    description = "Client implementation of the “Smart” HTTP Git protocol in pure OCaml";
-    inherit (git.meta) homepage license maintainers;
-  };
-}

pkgs/development/ocaml-modules/git-unix/default.nix

···
-{ stdenv, buildDunePackage, git-http, cohttp, cohttp-lwt-unix
-, mmap, cmdliner, mtime, alcotest, mirage-crypto-rng, tls
-, io-page, git-binary
-}:
-
-buildDunePackage {
-  pname = "git-unix";
-  inherit (git-http) version src minimumOCamlVersion;
-
-  useDune2 = true;
-
-  propagatedBuildInputs = [ mmap cmdliner git-http cohttp cohttp-lwt-unix mtime ];
-  checkInputs = [ alcotest mirage-crypto-rng tls io-page git-binary ];
-  doCheck = !stdenv.isAarch64;
-
-  meta = {
-    description = "Unix backend for the Git protocol(s)";
-    inherit (git-http.meta) homepage license maintainers;
-  };
-}

pkgs/development/ocaml-modules/git/cohttp-mirage.nix

···
+{ lib, buildDunePackage
+, git, mimic, cohttp-mirage, cohttp, cohttp-lwt
+, fmt, lwt, result, rresult, uri
+}:
+
+buildDunePackage {
+  pname = "git-cohttp-mirage";
+
+  inherit (git) version src minimumOCamlVersion useDune2;
+
+  propagatedBuildInputs = [
+    git mimic cohttp-mirage cohttp cohttp-lwt fmt lwt result rresult uri
+  ];
+
+  meta = git.meta // {
+    description = "A package to use HTTP-based ocaml-git with MirageOS backend";
+  };
+}

pkgs/development/ocaml-modules/git/cohttp-unix.nix

···
+{ buildDunePackage, git, git-cohttp
+, cohttp-lwt-unix, cohttp-lwt, fmt, lwt, result, rresult, uri
+}:
+
+buildDunePackage {
+  pname = "git-cohttp-unix";
+
+  inherit (git) version src minimumOCamlVersion useDune2;
+
+  propagatedBuildInputs = [
+    git git-cohttp cohttp-lwt-unix cohttp-lwt fmt lwt result rresult uri
+  ];
+
+  meta = git.meta // {
+    description = "A package to use HTTP-based ocaml-git with Unix backend";
+  };
+}

pkgs/development/ocaml-modules/git/cohttp.nix

···
+{ buildDunePackage, git
+, cohttp, cohttp-lwt, fmt, lwt, result, rresult, uri
+, alcotest, alcotest-lwt, bigstringaf, cstruct, logs
+, mirage-flow, ke
+}:
+
+buildDunePackage rec {
+  pname = "git-cohttp";
+
+  inherit (git) version minimumOCamlVersion src useDune2;
+
+  propagatedBuildInputs = [
+    git cohttp cohttp-lwt fmt lwt result rresult uri
+  ];
+
+  meta = git.meta // {
+    description = "A package to use HTTP-based ocaml-git with Unix backend";
+  };
+}

pkgs/development/ocaml-modules/git/default.nix

···
 { stdenv, lib, fetchurl, buildDunePackage
 , alcotest, mtime, mirage-crypto-rng, tls, git-binary
 , angstrom, astring, cstruct, decompress, digestif, encore, duff, fmt, checkseum
-, fpath, hex, ke, logs, lru, ocaml_lwt, ocamlgraph, ocplib-endian, uri, rresult
-, stdlib-shims
+, fpath, ke, logs, lwt, ocamlgraph, uri, rresult
+, result, bigstringaf, optint, mirage-flow, domain-name, emile
+, mimic, carton, carton-lwt, carton-git, ipaddr, psq, crowbar, alcotest-lwt
 }:
 
 buildDunePackage rec {
   pname = "git";
-  version = "2.1.3";
+  version = "3.2.0";
 
-  minimumOCamlVersion = "4.07";
+  minimumOCamlVersion = "4.08";
   useDune2 = true;
 
   src = fetchurl {
     url = "https://github.com/mirage/ocaml-git/releases/download/${version}/git-${version}.tbz";
-    sha256 = "1ppllv65vrkfrmx46aiq5879isffcjmg92z9rv2kh92a83h4lqax";
+    sha256 = "14rq7h1n5v2n0507ycbac8sq21xnzhgirxmlmqv4j5k3aajdcj16";
   };
 
   propagatedBuildInputs = [
     angstrom astring checkseum cstruct decompress digestif encore duff fmt fpath
-    hex ke logs lru ocaml_lwt ocamlgraph ocplib-endian uri rresult stdlib-shims
+    ke logs lwt ocamlgraph uri rresult result bigstringaf optint mirage-flow
+    domain-name emile mimic carton carton-lwt carton-git ipaddr psq
+  ];
+  checkInputs = [
+    alcotest alcotest-lwt mtime mirage-crypto-rng tls git-binary crowbar
   ];
-  checkInputs = [ alcotest mtime mirage-crypto-rng tls git-binary ];
   doCheck = !stdenv.isAarch64;
 
   meta = {

pkgs/development/ocaml-modules/git/unix.nix

···
+{ buildDunePackage, fetchpatch, git
+, mmap, rresult, result, bigstringaf
+, fmt, bos, fpath, uri, digestif, logs, lwt, git-cohttp-unix
+, mirage-clock, mirage-clock-unix, astring, awa, cmdliner
+, cohttp-lwt-unix, decompress, domain-name, ipaddr, mtime
+, tcpip, awa-mirage, mirage-flow
+, alcotest, alcotest-lwt, base64, cstruct
+, ke, mirage-crypto-rng, ocurl, git-binary
+}:
+
+buildDunePackage {
+  pname = "git-unix";
+  inherit (git) version src minimumOCamlVersion;
+
+  useDune2 = true;
+
+  buildInputs = [
+    awa awa-mirage cmdliner git-cohttp-unix
+    mirage-clock mirage-clock-unix tcpip
+  ];
+  propagatedBuildInputs = [
+    mmap rresult result bigstringaf
+    fmt bos fpath uri digestif logs lwt
+    astring cohttp-lwt-unix decompress
+    domain-name ipaddr mtime mirage-flow
+  ];
+  checkInputs = [
+    alcotest alcotest-lwt base64 cstruct ke
+    mirage-crypto-rng ocurl git-binary
+  ];
+  doCheck = true;
+
+  patches = [
+    (fetchpatch {
+      url = "https://github.com/mirage/ocaml-git/commit/09b41073fa869c0a595e1d8ed7224d539682af1c.patch";
+      sha256 = "1avbxv60gbrll9gny1pl6jwbx5b8282h3frhzy2ghb0fx1pggp6w";
+    })
+  ];
+
+  meta = {
+    description = "Unix backend for the Git protocol(s)";
+    inherit (git.meta) homepage license maintainers;
+  };
+}

pkgs/development/ocaml-modules/imagelib/default.nix

···
-{ lib, fetchFromGitHub, fetchpatch, buildDunePackage, decompress }:
+{ lib, fetchurl, buildDunePackage
+, decompress, stdlib-shims, alcotest
+}:
 
 buildDunePackage rec {
   minimumOCamlVersion = "4.07";
-  version = "20191011";
+  version = "20200929";
   pname = "imagelib";
 
   useDune2 = true;
 
-  src = fetchFromGitHub {
-    owner = "rlepigre";
-    repo = "ocaml-imagelib";
-    rev = "03fed7733825cef7e0465163f398f6af810e2e75";
-    sha256 = "0h7vgyss42nhlfqpbdnb54nxq86rskqi2ilx8b87r0hi19hqx463";
+  src = fetchurl {
+    url = "https://github.com/rlepigre/ocaml-imagelib/releases/download/ocaml-imagelib_${version}/imagelib-ocaml-imagelib_${version}.tbz";
+    sha256 = "1wyq4xxj0dxwafbcmd7jylsd8w1gbyl7j4ak6jbq1n0ardwmpwca";
   };
 
-  patches = [ (fetchpatch {
-    url = "https://github.com/rlepigre/ocaml-imagelib/pull/24/commits/4704fd44adcda62e0d96ea5b1927071326aa6111.patch";
-    sha256 = "0ipjab1hfa2v2pnd8g1k3q2ia0plgiw7crm3fa4w2aqpzdyabkb9";
-  }) ];
+  propagatedBuildInputs = [ decompress stdlib-shims ];
 
-  propagatedBuildInputs = [ decompress ];
+  doCheck = true;
+  checkInputs = [ alcotest ];
 
   meta = {
     description = "Image formats such as PNG and PPM in OCaml";
     license = lib.licenses.lgpl3;
     maintainers = [ lib.maintainers.vbgl ];
-    inherit (src.meta) homepage;
+    homepage = "https://github.com/rlepigre/ocaml-imagelib";
   };
 }

pkgs/development/ocaml-modules/imagelib/unix.nix

···
-{ buildDunePackage, imagelib }:
-
-buildDunePackage {
-  pname = "imagelib-unix";
-  inherit (imagelib) version src useDune2 meta;
-
-  propagatedBuildInputs = [ imagelib ];
-}

pkgs/development/ocaml-modules/index/default.nix

···
-{ lib, fetchurl, buildDunePackage, fmt, logs, mtime, stdlib-shims }:
+{ lib, fetchurl, buildDunePackage
+, repr, ppx_repr, fmt, logs, mtime, stdlib-shims
+, cmdliner, progress, semaphore-compat
+, alcotest, crowbar, re
+}:
 
 buildDunePackage rec {
   pname = "index";
-  version = "1.2.1";
+  version = "1.3.0";
 
-  minimumOCamlVersion = "4.07";
+  minimumOCamlVersion = "4.08";
+
+  useDune2 = true;
 
   src = fetchurl {
     url = "https://github.com/mirage/index/releases/download/${version}/index-${version}.tbz";
-    sha256 = "1a9b6rsazrjy07syxl9ix5002i95mlvx5vk7nl2x9cs6s0zw906d";
+    sha256 = "00qwhwg79scs5bgp8nbppv06qs9yhicf686q7lh64ngh0642iz6n";
   };
 
   buildInputs = [ stdlib-shims ];
-  propagatedBuildInputs = [ fmt logs mtime ];
+  propagatedBuildInputs = [
+    fmt logs mtime repr ppx_repr cmdliner progress semaphore-compat
+  ];
+
+  doCheck = true;
+  checkInputs = [ alcotest crowbar re ];
 
   meta = {
     homepage = "https://github.com/mirage/index";
···
     license = lib.licenses.mit;
     maintainers = [ lib.maintainers.vbgl ];
   };
-
 }

pkgs/development/ocaml-modules/irmin/chunk.nix

···
-{ lib, buildDunePackage, irmin, irmin-mem, irmin-test }:
+{ lib, buildDunePackage, irmin, irmin-test, alcotest }:
 
 buildDunePackage rec {
 
···
   propagatedBuildInputs = [ irmin ];
 
   doCheck = true;
-  checkInputs = [ irmin-mem irmin-test ];
+  checkInputs = [ alcotest irmin-test ];
 
   meta = irmin.meta // {
     description = "Irmin backend which allow to store values into chunks";

pkgs/development/ocaml-modules/irmin/containers.nix

···
+{ buildDunePackage
+, irmin, irmin-unix, irmin-git, ppx_irmin, lwt, mtime
+, alcotest, alcotest-lwt
+}:
+
+buildDunePackage {
+  pname = "irmin-containers";
+
+  inherit (ppx_irmin) src version useDune2;
+
+  nativeBuildInputs = [
+    ppx_irmin
+  ];
+
+  propagatedBuildInputs = [
+    irmin irmin-unix irmin-git ppx_irmin lwt mtime
+  ];
+
+  doCheck = true;
+  checkInputs = [
+    alcotest alcotest-lwt
+  ];
+
+  meta = ppx_irmin.meta // {
+    description = "Mergeable Irmin data structures";
+  };
+}

pkgs/development/ocaml-modules/irmin/default.nix

···
-{ lib, fetchurl, buildDunePackage
+{ lib, buildDunePackage
 , astring, base64, digestif, fmt, jsonm, logs, ocaml_lwt, ocamlgraph, uri
-, alcotest, hex, ppx_irmin
+, repr, ppx_irmin, bheap
 }:
 
 buildDunePackage {
···
   useDune2 = true;
   minimumOCamlVersion = "4.07";
 
-  propagatedBuildInputs = [ astring base64 digestif fmt jsonm logs ocaml_lwt ocamlgraph uri ];
+  propagatedBuildInputs = [
+    astring
+    base64
+    digestif
+    fmt
+    jsonm
+    logs
+    ocaml_lwt
+    ocamlgraph
+    uri
+    repr
+    bheap
+    ppx_irmin
+  ];
 
-  checkInputs = [ alcotest hex ppx_irmin ];
-  doCheck = true;
+  # circular dependency on irmin-mem
+  doCheck = false;
 
   meta = ppx_irmin.meta // {
     description = "A distributed database built on the same principles as Git";

pkgs/development/ocaml-modules/irmin/git.nix

···
-{ lib, buildDunePackage, git, irmin, irmin-mem, irmin-test, git-unix }:
+{ lib, buildDunePackage
+, git, irmin, irmin-test, ppx_irmin, git-cohttp-unix, git-unix
+, digestif, cstruct, fmt, astring, fpath, logs, lwt, uri
+, mtime, alcotest
+}:
 
-buildDunePackage rec {
+buildDunePackage {
 
   pname = "irmin-git";
 
···
 
   useDune2 = true;
 
-  propagatedBuildInputs = [ git irmin ];
+  propagatedBuildInputs = [
+    git
+    irmin
+    ppx_irmin
+    digestif
+    cstruct
+    fmt
+    astring
+    fpath
+    logs
+    lwt
+    uri
+  ];
 
-  checkInputs = lib.optionals doCheck [ git-unix irmin-mem irmin-test ];
+  checkInputs = [ mtime alcotest git-cohttp-unix git-unix irmin-test ];
 
   doCheck = true;
 

pkgs/development/ocaml-modules/irmin/http.nix

···
 { lib, buildDunePackage, cohttp-lwt, irmin, webmachine
-, checkseum, git-unix, irmin-git, irmin-mem, irmin-test
+, checkseum, git-unix, irmin-git, irmin-test, digestif, git-cohttp-unix
 }:
 
 buildDunePackage rec {
···
 
   propagatedBuildInputs = [ cohttp-lwt irmin webmachine ];
 
-  checkInputs = lib.optionals doCheck [ checkseum git-unix irmin-git irmin-mem irmin-test ];
+  checkInputs = [ digestif checkseum git-cohttp-unix git-unix irmin-git irmin-test ];
 
   doCheck = true;
 

pkgs/development/ocaml-modules/irmin/layers.nix

···
+{ buildDunePackage, irmin, mtime, logs, lwt }:
+
+buildDunePackage {
+  pname = "irmin-layers";
+
+  inherit (irmin) version src useDune2;
+
+  propagatedBuildInputs = [
+    irmin
+    mtime
+    logs
+    lwt
+  ];
+
+  # mutual dependency on irmin-test
+  doCheck = false;
+
+  meta = irmin.meta // {
+    description = "Combine different Irmin stores into a single, layered store";
+  };
+}

pkgs/development/ocaml-modules/irmin/mem.nix

···
-{ lib, buildDunePackage, irmin, irmin-test }:
-
-buildDunePackage rec {
-
-  pname = "irmin-mem";
-
-  inherit (irmin) version src;
-
-  useDune2 = true;
-
-  propagatedBuildInputs = [ irmin ];
-
-  checkInputs = lib.optional doCheck irmin-test;
-
-  doCheck = true;
-
-  meta = irmin.meta // {
-    description = "Generic in-memory Irmin stores";
-  };
-
-}

pkgs/development/ocaml-modules/irmin/mirage-git.nix

···
+{ buildDunePackage, irmin-mirage, irmin-git
+, mirage-kv, cohttp, conduit-lwt, conduit-mirage
+, git-cohttp-mirage, fmt, git, lwt, mirage-clock, uri
+}:
+
+buildDunePackage {
+  pname = "irmin-mirage-git";
+
+  inherit (irmin-mirage) version src useDune2;
+
+  propagatedBuildInputs = [
+    irmin-mirage
+    irmin-git
+    mirage-kv
+    cohttp
+    conduit-lwt
+    conduit-mirage
+    git-cohttp-mirage
+    fmt
+    git
+    lwt
+    mirage-clock
+    uri
+  ];
+
+  inherit (irmin-mirage) meta;
+}

pkgs/development/ocaml-modules/irmin/mirage-graphql.nix

···
+{ buildDunePackage, irmin-mirage, irmin-graphql
+, mirage-clock, cohttp-lwt, lwt, uri, git
+}:
+
+buildDunePackage {
+  pname = "irmin-mirage-graphql";
+
+  inherit (irmin-mirage) version src useDune2;
+
+  propagatedBuildInputs = [
+    irmin-mirage
+    irmin-graphql
+    mirage-clock
+    cohttp-lwt
+    lwt
+    uri
+    git
+  ];
+
+  inherit (irmin-mirage) meta;
+}

pkgs/development/ocaml-modules/irmin/mirage.nix

···
+{ buildDunePackage, irmin, fmt, ptime, mirage-clock }:
+
+buildDunePackage {
+  pname = "irmin-mirage";
+
+  inherit (irmin) version src useDune2;
+
+  propagatedBuildInputs = [
+    irmin fmt ptime mirage-clock
+  ];
+
+  meta = irmin.meta // {
+    description = "MirageOS-compatible Irmin stores";
+  };
+}

pkgs/development/ocaml-modules/irmin/pack.nix

···
-{ lib, buildDunePackage, alcotest-lwt, index, irmin, irmin-test, ocaml_lwt }:
+{ lib, buildDunePackage
+, alcotest-lwt, index, irmin, irmin-layers, irmin-test, ocaml_lwt, fpath
+}:
 
 buildDunePackage rec {
   minimumOCamlVersion = "4.02.3";
···
 
   useDune2 = true;
 
-  propagatedBuildInputs = [ index irmin ocaml_lwt ];
+  buildInputs = [ fpath ];
+  propagatedBuildInputs = [ index irmin irmin-layers ocaml_lwt ];
 
-  checkInputs = lib.optionals doCheck [ alcotest-lwt irmin-test ];
+  checkInputs = [ alcotest-lwt irmin-test ];
 
   doCheck = true;
 

pkgs/development/ocaml-modules/irmin/ppx.nix

···
-{ lib, fetchurl, buildDunePackage, ppxlib, ocaml-syntax-shims }:
+{ lib, fetchurl, buildDunePackage, ppxlib, ppx_repr }:
 
 buildDunePackage rec {
   pname = "ppx_irmin";
-  version = "2.2.0";
+  version = "2.4.0";
 
   src = fetchurl {
     url = "https://github.com/mirage/irmin/releases/download/${version}/irmin-${version}.tbz";
-    sha256 = "0gzw918b661qkvd140hilww9jsc49rxsxz1k4iihyvikjn202km4";
+    sha256 = "1b6lav5br1b83cwdc3gj9mqkzhlbfjrbyjx0107zvj54m82dbrxb";
   };
 
-  minimumOCamlVersion = "4.06";
+  minimumOCamlVersion = "4.08";
 
   useDune2 = true;
 
-  buildInputs = [ ocaml-syntax-shims ];
-  propagatedBuildInputs = [ ppxlib ];
+  propagatedBuildInputs = [
+    ppx_repr
+    ppxlib
+  ];
 
   # tests depend on irmin, would create mutual dependency
-  # opt to test irmin instead of ppx_irmin
   doCheck = false;
 
   meta = {

pkgs/development/ocaml-modules/irmin/test.nix

···
-{ buildDunePackage, alcotest, cmdliner, irmin, metrics-unix, mtime }:
+{ buildDunePackage
+, alcotest, cmdliner, irmin, metrics-unix, mtime, irmin-layers
+}:
 
 buildDunePackage {
 
···
 
   useDune2 = true;
 
-  propagatedBuildInputs = [ alcotest cmdliner irmin metrics-unix mtime ];
+  propagatedBuildInputs = [
+    alcotest cmdliner irmin metrics-unix mtime irmin-layers
+  ];
 
   meta = irmin.meta // {
     description = "Irmin test suite";

pkgs/development/ocaml-modules/irmin/unix.nix

···
 { lib, buildDunePackage
-, checkseum, cmdliner, git-unix, yaml
-, irmin, irmin-fs, irmin-git, irmin-graphql, irmin-http, irmin-mem, irmin-pack, irmin-watcher
-, irmin-test
+, checkseum, cmdliner, git-unix, git-cohttp-unix, yaml, fpath
+, irmin, irmin-fs, irmin-git, irmin-graphql, irmin-http
+, irmin-pack, irmin-watcher, irmin-test
 }:
 
 buildDunePackage rec {
···
 
   useDune2 = true;
 
-  propagatedBuildInputs = [ checkseum cmdliner git-unix yaml
-    irmin irmin-fs irmin-git irmin-graphql irmin-http irmin-mem irmin-pack irmin-watcher
+  propagatedBuildInputs = [
+    checkseum cmdliner git-unix yaml fpath
+    irmin irmin-fs irmin-git irmin-graphql irmin-http
+    irmin-pack irmin-watcher git-cohttp-unix
   ];
 
   checkInputs = lib.optional doCheck irmin-test;

pkgs/development/ocaml-modules/ocaml-gettext/default.nix

···
 
   minimumOCamlVersion = "4.03";
 
+  useDune2 = true;
+
   src = fetchurl {
     url = "https://github.com/gildor478/ocaml-gettext/releases/download/v${version}/gettext-v${version}.tbz";
     sha256 = "19ynsldb21r539fiwz1f43apsdnx7hj2a2d9qr9wg2hva9y2qrwb";

pkgs/development/ocaml-modules/ocaml-gettext/stub.nix

···
-{ lib, buildDunePackage, ocaml_gettext, ounit }:
+{ buildDunePackage, ocaml_gettext, dune-configurator, ounit }:
 
 buildDunePackage rec {
 
   pname = "gettext-stub";
 
-  inherit (ocaml_gettext) src version meta;
+  inherit (ocaml_gettext) src version useDune2 meta;
+
+  buildInputs = [ dune-configurator ];
 
   propagatedBuildInputs = [ ocaml_gettext ];
 
   doCheck = true;
 
-  checkInputs = lib.optional doCheck ounit;
+  checkInputs = [ ounit ];
 }

pkgs/development/ocaml-modules/wodan/irmin.nix

···
     wodan
   ];
 
-  meta = wodan.meta // { description = "Wodan as an Irmin store"; };
-
+  meta = wodan.meta // {
+    # wodan is currently incompatible with irmin 2.3.0.
+    # additionally upgrading to current master (unclear
+    # if the issue is fixed there) is not possible as it
+    # depends on a custom fork of mirage-block
+    broken = true;
+    description = "Wodan as an Irmin store";
+  };
 }

pkgs/development/python-modules/aioesphomeapi/default.nix

···
 
 buildPythonPackage rec {
   pname = "aioesphomeapi";
-  version = "2.6.4";
+  version = "2.6.5";
 
   disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "d8def7a909c0471479e1d8b0965de6bb7644b8de315d6e578f9d848b8a6812d0";
+    sha256 = "sha256-inktluPKefrFQCF2yadvHwT9Rw+pJLw8pjdUc35IJoc=";
   };
 
   propagatedBuildInputs = [ attrs protobuf zeroconf ];

pkgs/development/python-modules/hatasmota/default.nix

···
 
 buildPythonPackage rec {
   pname = "hatasmota";
-  version = "0.2.8";
+  version = "0.2.9";
 
   src = fetchFromGitHub {
     owner = "emontnemery";
     repo = pname;
     rev = version;
-    sha256 = "sha256-DuVpo+g5VS7bkj/DZi0vNOAPjPkzfIA5I2BD5KJ/rNQ=";
+    sha256 = "sha256-+4jlzemF5f4Qz4QHDaErsmVHq1Pjn/vsvoq/oCbW/hI=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/jupyterhub/default.nix

···
 { lib
 , buildPythonPackage
+, pythonOlder
 , fetchPypi
 , fetchzip
 , alembic
-, ipython
-, jinja2
-, python-oauth2
-, prometheus_client
 , async_generator
+, certipy
+, dateutil
+, entrypoints
+, jinja2
+, jupyter-telemetry
+, oauthlib
 , pamela
+, prometheus_client
+, requests
 , sqlalchemy
 , tornado
 , traitlets
-, requests
-, notebook
-, pythonOlder
 , nodePackages
-, oauthlib
-, certipy
-, jupyter-telemetry
+, beautifulsoup4
+, cryptography
+, notebook
+, pytest-asyncio
+, pytestCheckHook
+, requests-mock
+, virtualenv
 }:
 
 let
   # js/css assets that setup.py tries to fetch via `npm install` when building
-  # from source.
+  # from source. https://github.com/jupyterhub/jupyterhub/blob/master/package.json
   bootstrap =
     fetchzip {
-      url = "https://registry.npmjs.org/bootstrap/-/bootstrap-3.3.7.tgz";
-      sha256 = "0r7s54bbf68ri1na9bbabyf12mcpb6zk5ja2q6z82aw1fa4xi3yd";
+      url = "https://registry.npmjs.org/bootstrap/-/bootstrap-3.4.1.tgz";
+      sha256 = "1ywmxqdccg0mgx0xknrn1hlrfnhcwphc12y9l91zizx26fqfmzgc";
     };
   font-awesome =
     fetchzip {
···
     };
   jquery =
     fetchzip {
-      url = "https://registry.npmjs.org/jquery/-/jquery-3.2.1.tgz";
-      sha256 = "1j6y18miwzafdj8kfpwbmbn9qvgnbnpc7l4arqrhqj33m04xrlgi";
+      url = "https://registry.npmjs.org/jquery/-/jquery-3.5.1.tgz";
+      sha256 = "0yi9ql493din1qa1s923nd5zvd0klk1sx00xj1wx2yambmq86vm9";
     };
   moment =
     fetchzip {
-      url = "https://registry.npmjs.org/moment/-/moment-2.22.2.tgz";
-      sha256 = "12gb3p0rz5wyjwykv9g0pix7dd352lx1z7rzdjsf2brhwc4ffyip";
+      url = "https://registry.npmjs.org/moment/-/moment-2.24.0.tgz";
+      sha256 = "0ifzzla4zffw23g3xvhwx3fj3jny6cjzxfzl1x0317q8wa0c7w5i";
     };
   requirejs =
     fetchzip {
-      url = "https://registry.npmjs.org/requirejs/-/requirejs-2.3.4.tgz";
-      sha256 = "0q6mkj0iv341kks06dya6lfs2kdw0n6vc7n4a7aa3ia530fk9vja";
+      url = "https://registry.npmjs.org/requirejs/-/requirejs-2.3.6.tgz";
+      sha256 = "165hkli3qcd59cjqvli9r5f92i0h7czkmhcg1cgwamw2d0b7xibz";
     };
 
 in
 
 buildPythonPackage rec {
   pname = "jupyterhub";
-  version = "1.1.0";
-  disabled = pythonOlder "3.5";
+  version = "1.3.0";
+  disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1mqknz0rxqzx4nc57vscvfh2d4znzlzpy83ancqxdaq3b8i70al5";
+    sha256 = "13pf6qhimpaxj20871ff5rvwwan59320cdhhrn9cfh6314971zq5";
   };
 
   # Most of this only applies when building from source (e.g. js/css assets are
···
       "'${nodePackages.configurable-http-proxy}/bin/configurable-http-proxy'"
 
     substituteInPlace setup.py --replace \
-      "'npm', 'run', 'lessc', '--'" \
-      "'${nodePackages.less}/bin/lessc'"
-
-    substituteInPlace setup.py --replace \
-      "'npm', 'install', '--progress=false'" \
-      "'true'"
+      "'npm'" "'true'"
 
     declare -A deps
     deps[bootstrap]=${bootstrap}
···
   '';
 
   propagatedBuildInputs = [
-    alembic ipython jinja2 pamela python-oauth2 requests sqlalchemy tornado
-    traitlets prometheus_client async_generator notebook certipy oauthlib
+    # https://github.com/jupyterhub/jupyterhub/blob/master/requirements.txt
+    alembic
+    async_generator
+    certipy
+    dateutil
+    entrypoints
+    jinja2
     jupyter-telemetry
+    oauthlib
+    pamela
+    prometheus_client
+    requests
+    sqlalchemy
+    tornado
+    traitlets
   ];
 
-  # Disable tests because they take an excessive amount of time to complete.
-  doCheck = false;
+  preCheck = ''
+    substituteInPlace jupyterhub/tests/test_spawner.py --replace \
+      "'jupyterhub-singleuser'" "'$out/bin/jupyterhub-singleuser'"
+  '';
 
+  checkInputs = [
+    # https://github.com/jupyterhub/jupyterhub/blob/master/dev-requirements.txt
+    beautifulsoup4
+    cryptography
+    notebook
+    pytest-asyncio
+    pytestCheckHook
+    requests-mock
+    virtualenv
+  ];
+
+  disabledTests = [
+    # Tries to install older versions through pip
+    "test_upgrade"
+    # Testcase fails to find requests import
+    "test_external_service"
+  ];
 
   meta = with lib; {
     description = "Serves multiple Jupyter notebook instances";

pkgs/development/python-modules/oauthenticator/default.nix

···
 { lib
 , buildPythonPackage
+, pythonOlder
+, fetchPypi
+, google_api_python_client
+, google-auth-oauthlib
 , jupyterhub
-, globus-sdk
 , mwoauth
-, codecov
-, flake8
 , pyjwt
-, pytest
-, pytestcov
-, pytest-tornado
+, pytest-asyncio
+, pytestCheckHook
 , requests-mock
-, pythonOlder
-, fetchPypi
 }:
 
 buildPythonPackage rec {
   pname = "oauthenticator";
-  version = "0.12.3";
+  version = "0.13.0";
+  disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "f86e18e954ae37796ee149fe01ab0be0707d9e0415d62336ba3447e7b4383461";
+    sha256 = "5202adcd96ddbbccbc267da02f2d14e977300c81291aaa77be4fd9f2e27cfa37";
   };
 
-  checkPhase = ''
-    py.test oauthenticator/tests
-  '';
+  propagatedBuildInputs = [
+    jupyterhub
+  ];
 
-  # No tests in archive
-  doCheck = false;
+  pytestFlagsArray = [ "oauthenticator/tests" ];
 
-  checkInputs = [  globus-sdk mwoauth codecov flake8 pytest
-    pytestcov pytest-tornado requests-mock pyjwt ];
-
-  propagatedBuildInputs = [ jupyterhub ];
-
-  disabled = pythonOlder "3.4";
+  checkInputs = [
+    google_api_python_client
+    google-auth-oauthlib
+    mwoauth
+    pyjwt
+    pytest-asyncio
+    pytestCheckHook
+    requests-mock
+  ];
 
   meta = with lib; {
     description = "Authenticate JupyterHub users with common OAuth providers, including GitHub, Bitbucket, and more.";

pkgs/development/python-modules/xarray/default.nix

···
 { lib
 , buildPythonPackage
 , fetchPypi
-, pytest
+, pytestCheckHook
 , numpy
 , pandas
-, python
 , setuptools
 , isPy3k
 }:
 
 buildPythonPackage rec {
   pname = "xarray";
-  version = "0.16.1";
+  version = "0.16.2";
+  disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "5e1af056ff834bf62ca57da917159328fab21b1f8c25284f92083016bb2d92a5";
+    sha256 = "sha256-OOhDnWyRvNW3wPyjSdr44GQ6xohQyYcmLVNSbp19AeQ=";
   };
 
-  checkInputs = [ pytest ];
   propagatedBuildInputs = [ numpy pandas setuptools ];
+  checkInputs = [ pytestCheckHook ];
 
-  checkPhase = ''
-    pytest $out/${python.sitePackages}
-  '';
-
-  # There always seem to be broken tests...
-  doCheck = false;
-
-  disabled = !isPy3k;
+  pythonImportsCheck = [ "xarray" ];
 
   meta = {
     description = "N-D labeled arrays and datasets in Python";

pkgs/development/r-modules/cran-packages.nix

···
   arrApply = derive2 { name="arrApply"; version="2.1"; sha256="0qy7iwi580rrf3sycsbv6qgxsqcdy9pdbnkdrx81j68qni9iw737"; depends=[Rcpp RcppArmadillo]; };
   arrangements = derive2 { name="arrangements"; version="1.1.9"; sha256="0nrlyxgn6667l2rb1q5rvps1anld9aq88qqr3ch2i6zchnqxrdg9"; depends=[gmp R6]; };
   arrayhelpers = derive2 { name="arrayhelpers"; version="1.1-0"; sha256="02rl530qxi1idiqpmzg5wr9vl5c7phizhpj64k5pn8xq9zfxbpaz"; depends=[svUnit]; };
-  arrow = derive2 { name="arrow"; version="2.0.0"; sha256="0n9g8j7bis7aga2icc8gd6mv7fnh2d5m7fy62fqs4z69l69y19r8"; depends=[assertthat bit64 cpp11 purrr R6 rlang tidyselect vctrs]; };
+  arrow = derive { snapshot = "2021-02-01"; } { name="arrow"; version="3.0.0"; sha256="0wgdj6fr4vbz91s76gfwyv2q66p8z3fwf9zgk4112rjhj60q7qfq"; depends=[assertthat bit64 cpp11 purrr R6 rlang tidyselect vctrs]; };
   ars = derive2 { name="ars"; version="0.6"; sha256="0zs1rk3i7pc9wcvxrvjcls194mfbvmkz7cb6pwd1cm3fzjwsyxsp"; depends=[]; };
   arse = derive2 { name="arse"; version="1.0.0"; sha256="0ssaalc058m09gfcr1n0s729rx2plia3zkhlynj67drclyvhyb0i"; depends=[dplyr pracma]; };
   arsenal = derive2 { name="arsenal"; version="3.5.0"; sha256="0avi434wkk3w7axd89a4jwsbb11fi0239mkkla6zasnjwbqgjim0"; depends=[knitr]; };

pkgs/development/r-modules/default.nix

···
   };
 
   packagesWithNativeBuildInputs = {
+    arrow = [ pkgs.pkgconfig pkgs.arrow-cpp ];
     adimpro = [ pkgs.imagemagick ];
     animation = [ pkgs.which ];
     audio = [ pkgs.portaudio ];

pkgs/development/tools/rubocop/Gemfile.lock

···
     rainbow (3.0.0)
     regexp_parser (2.0.3)
     rexml (3.2.4)
-    rubocop (1.9.1)
+    rubocop (1.10.0)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)

pkgs/development/tools/rubocop/gemset.nix

···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "06npybjypxsrz09z8ivxqfcwzpbgif6z3hwpp0ls8znqlgp3m922";
+      sha256 = "1ncd6w4sc112j86j9j12ws7flxfi8dk8nal2kyxg7phdfr703qlz";
       type = "gem";
     };
-    version = "1.9.1";
+    version = "1.10.0";
   };
   rubocop-ast = {
     dependencies = ["parser"];

pkgs/misc/emulators/ryujinx/default.nix

···
   ];
 in stdenv.mkDerivation rec {
   pname = "ryujinx";
-  version = "1.0.6498"; # Versioning is based off of the official appveyor builds: https://ci.appveyor.com/project/gdkchan/ryujinx
+  version = "1.0.6574"; # Versioning is based off of the official appveyor builds: https://ci.appveyor.com/project/gdkchan/ryujinx
 
   src = fetchFromGitHub {
     owner = "Ryujinx";
     repo = "Ryujinx";
-    rev = "67033ed8e05eb70860ac6af2b83deab0256c11eb";
-    sha256 = "1lg0cybbrf0x3jl10jwdwcg1zyhxsqfdnwnsvdm1lah75xg15ymw";
+    rev = "80ed8596c165127fb52026c697a9b6b515dabbd4";
+    sha256 = "0jhrl8g9fbz3w2hzmy9jm22cvjfa0x5vh3912rz1rvnd41qb9vs8";
   };
 
   nativeBuildInputs = [ dotnet-sdk_5 dotnetPackages.Nuget cacert makeWrapper wrapGAppsHook gobject-introspection gdk-pixbuf ];
···
 
     export HOME=$(mktemp -d)
     export DOTNET_CLI_TELEMETRY_OPTOUT=1
-    export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
+    export DOTNET_NOLOGO=1
 
     nuget sources Add -Name nixos -Source "$PWD/nixos"
     nuget init "$nugetDeps" "$PWD/nixos"

pkgs/tools/admin/clair/default.nix

···
 
 buildGoModule rec {
   pname = "clair";
-  version = "4.0.0";
+  version = "4.0.1";
 
   src = fetchFromGitHub {
     owner = "quay";
     repo = pname;
     rev = "v${version}";
-    sha256 = "10kgg2i5yzdfhylrdkmh8rsc4cgdnhcgfa8fa4dm8m3licjciwam";
+    sha256 = "sha256-FJqUYQDDOuO0EcZ8+el/MUcJJzWL7vgGhEFo7v4HpOw=";
   };
 
-  vendorSha256 = "1l3b86f5xmyc6lskvb4ab30adcgzb69ayccc0wcz2f28sda3i80r";
+  vendorSha256 = "sha256-CO4U8uSQeHXLPj5PH/SsOI/LjT2Rs/mBHsvNTudx72I=";
 
   doCheck = false;
 

pkgs/tools/admin/google-cloud-sdk/default.nix

···
   sources = name: system: {
     x86_64-darwin = {
       url = "${baseUrl}/${name}-darwin-x86_64.tar.gz";
-      sha256 = "09pv1xvycgfai151z6kbsggyldcd3cx6x1p04dcim2xrawqvng6s";
+      sha256 = "135xbaz6q4565mklxjmm4mybm5qayvz34m0bdg609597kxw6l97j";
     };
 
     x86_64-linux = {
       url = "${baseUrl}/${name}-linux-x86_64.tar.gz";
-      sha256 = "1iybbvxjny33mw3h2f81fdvsvp65xa62c2qrzjv8hkrqkw69ckrp";
+      sha256 = "1i4cp6kyqbqj0fnmwx11bq6a1k4hrhyxz9qifr1qjfi7n8ybqrqy";
     };
   }.${system};
 
 in stdenv.mkDerivation rec {
   pname = "google-cloud-sdk";
-  version = "325.0.0";
+  version = "327.0.0";
 
   src = fetchurl (sources "${pname}-${version}" stdenv.hostPlatform.system);
 
···
   nativeBuildInputs = [ jq ];
 
   patches = [
+    # For kubectl configs, don't store the absolute path of the `gcloud` binary as it can be garbage-collected
     ./gcloud-path.patch
+    # Disable checking for updates for the package
     ./gsutil-disable-updates.patch
   ];
 
   installPhase = ''
+    runHook preInstall
+
     mkdir -p $out/google-cloud-sdk
     cp -R * .install $out/google-cloud-sdk/
 
···
       jq -c . $path > $path.min
       mv $path.min $path
     done
+
+    runHook postInstall
   '';
 
   meta = with lib; {

pkgs/tools/misc/dua/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "dua";
-  version = "2.10.10";
+  version = "2.11.0";
 
   src = fetchFromGitHub {
     owner = "Byron";
     repo = "dua-cli";
     rev = "v${version}";
-    sha256 = "sha256-Rt+60j1+uwL6g4HGc+xdUzGK6nanGfRYbekO54iKsPE=";
+    sha256 = "sha256-c+3zB0bxohQQsOjcTLHgRQamJfm7iUdz79t8q8wAFL8=";
     # Remove unicode file names which leads to different checksums on HFS+
     # vs. other filesystems because of unicode normalisation.
     extraPostFetch = ''
···
     '';
   };
 
-  cargoSha256 = "sha256-6L1J5RHI657Z03rMmhwEzgpQ0//dykqGi8bI2Enc3N8=";
+  cargoSha256 = "sha256-ORkj6T9O/NKuaILm5NFGePYxKMaCAAydascelaEvYVw=";
 
   doCheck = false;
 

pkgs/tools/misc/fend/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "fend";
-  version = "0.1.13";
+  version = "0.1.14";
 
   src = fetchFromGitHub {
     owner = "printfn";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-dz6vGRsWc7ubc/drj2Qw/of8AciPgVzc4++Eozg0Luo=";
+    sha256 = "sha256-zKjYUkkm15YRF0YFJKi2A6twvmHuEyxdWcNs37r2dJg=";
   };
 
-  cargoSha256 = "sha256-/HBTmLZLhv89mvIVLocw9XbfOgxh9KsjA6KT60IuJeA=";
+  cargoSha256 = "sha256-e95DRhD22zvizUJOM2It45Bx05iK3KtaMgFPkMbR7iI=";
+
+  doInstallCheck = true;
+
+  installCheckPhase = ''
+    [[ "$($out/bin/fend "1 km to m")" = "1000 m" ]]
+  '';
 
   meta = with lib; {
     description = "Arbitrary-precision unit-aware calculator";

pkgs/tools/misc/savepagenow/default.nix

···
+{ lib, python3Packages, fetchFromGitHub }:
+
+python3Packages.buildPythonApplication rec {
+  pname = "savepagenow";
+  version = "1.1.1";
+
+  src = fetchFromGitHub {
+    owner = "pastpages";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1lz6rc47cds9rb35jdf8n13gr61wdkh5jqzx4skikm1yrqkwjyhm";
+  };
+
+  propagatedBuildInputs = with python3Packages; [ click requests ];
+
+  # requires network access
+  doCheck = false;
+
+  meta = with lib; {
+    description = "A simple Python wrapper for archive.org's \"Save Page Now\" capturing service";
+    homepage = "https://github.com/pastpages/savepagenow";
+    license = licenses.mit;
+    maintainers = with maintainers; [ SuperSandro2000 ];
+  };
+}

pkgs/tools/misc/skim/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "skim";
-  version = "0.9.3";
+  version = "0.9.4";
 
   src = fetchCrate {
     inherit pname version;
-    sha256 = "026mgqcp9sg6wwikghrc3rgh5p6wdbnvav5pb3xvs79lj85d5ga7";
+    sha256 = "0yvjzmz2vqc63l8911jflqf5aww7wxsav2yal5wg9ci9hzq6dl7j";
   };
 
   outputs = [ "out" "vim" ];
 
-  cargoSha256 = "07bs23x2vxzlrca5swwq8khmd9fbdhlhm0avwp9y231df6xdi2ys";
+  cargoSha256 = "0xh4f8c62kzj2fx7hyhdy13zhay13a6d2d7i9yz0n40dfgf70qx0";
 
   postPatch = ''
     sed -i -e "s|expand('<sfile>:h:h')|'$out'|" plugin/skim.vim

pkgs/tools/misc/topgrade/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "topgrade";
-  version = "6.5.0";
+  version = "6.5.1";
 
   src = fetchFromGitHub {
     owner = "r-darwish";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-O2k9eUs+aopwtT/DXYIv9pc9z8W4K6cXUE6diqNDTrg=";
+    sha256 = "sha256-5S9mKmnrycrL7DFq8duWVbzEHQfiXAXQYcc3bdiVu1k=";
   };
 
-  cargoSha256 = "1yjhphw680cf93lgknksa67k0w0rhq6s3jinyn649wd71gbc5656";
+  cargoSha256 = "0sbkqdwfsfb7q52a9vh5lmggrc8ny2l0xr4qx3m42xm0h64f3y6n";
 
   buildInputs = lib.optional stdenv.isDarwin Foundation;
 

pkgs/tools/networking/xh/default.nix

···
   meta = with lib; {
     description = "Yet another HTTPie clone in Rust";
     homepage = "https://github.com/ducaale/xh";
+    changelog = "https://github.com/ducaale/xh/blob/v${version}/CHANGELOG.md";
     license = licenses.mit;
     maintainers = with maintainers; [ payas SuperSandro2000 ];
   };

pkgs/top-level/aliases.nix

···
   cpp_ethereum = throw "cpp_ethereum has been removed; abandoned upstream."; # added 2020-11-30
   cryptol = throw "cryptol was removed due to prolonged broken build"; # added 2020-08-21
   cpp-gsl = microsoft_gsl; # added 2019-05-24
+  cudatoolkit_6 = throw "cudatoolkit_6 has been removed in favor of newer versions"; # added 2021-02-14
+  cudatoolkit_65 = throw "cudatoolkit_65 has been removed in favor of newer versions"; # added 2021-02-14
+  cudatoolkit_7 = throw "cudatoolkit_7 has been removed in favor of newer versions"; # added 2021-02-14
+  cudatoolkit_7_5 = throw "cudatoolkit_7_5 has been removed in favor of newer versions"; # added 2021-02-14
+  cudatoolkit_8 = throw "cudatoolkit_8 has been removed in favor of newer versions"; # added 2021-02-14
+  cudnn_cudatoolkit_7 = throw "cudnn_cudatoolkit_7 has been removed in favor of newer versions"; # added 2021-02-14
+  cudnn_cudatoolkit_7_5 = throw "cudnn_cudatoolkit_7_5 has been removed in favor of newer versions"; # added 2021-02-14
+  cudnn6_cudatoolkit_8 = throw "cudnn6_cudatoolkit_8 has been removed in favor of newer versions"; # added 2021-02-14
+  cudnn_cudatoolkit_8 = throw "cudnn_cudatoolkit_8 has been removed in favor of newer versions"; # added 2021-02-14
   cupsBjnp = cups-bjnp; # added 2016-01-02
   cups_filters = cups-filters; # added 2016-08
   cups-googlecloudprint = throw "Google Cloudprint is officially discontinued since Jan 2021, more info https://support.google.com/chrome/a/answer/9633006";

pkgs/top-level/all-packages.nix

···
 
   cudaPackages = recurseIntoAttrs (callPackage ../development/compilers/cudatoolkit {});
   inherit (cudaPackages)
-    cudatoolkit_6
-    cudatoolkit_6_5
-    cudatoolkit_7
-    cudatoolkit_7_5
-    cudatoolkit_8
     cudatoolkit_9
     cudatoolkit_9_0
     cudatoolkit_9_1
···
 
   cudnnPackages = callPackages ../development/libraries/science/math/cudnn { };
   inherit (cudnnPackages)
-    cudnn_cudatoolkit_7
-    cudnn_cudatoolkit_7_5
-    cudnn6_cudatoolkit_8
-    cudnn_cudatoolkit_8
     cudnn_cudatoolkit_9
     cudnn_cudatoolkit_9_0
     cudnn_cudatoolkit_9_1
···
 
   sarasa-gothic = callPackage ../data/fonts/sarasa-gothic { };
 
+  savepagenow = callPackage ../tools/misc/savepagenow { };
+
   scheme-manpages = callPackage ../data/documentation/scheme-manpages { };
 
   scowl = callPackage ../data/misc/scowl { };
···
   k9s = callPackage ../applications/networking/cluster/k9s { };
 
   popeye = callPackage ../applications/networking/cluster/popeye { };
+
+  kube-capacity = callPackage ../applications/networking/cluster/kube-capacity { };
 
   fluxctl = callPackage ../applications/networking/cluster/fluxctl { };
 

pkgs/top-level/ocaml-packages.nix

···
 
     ca-certs = callPackage ../development/ocaml-modules/ca-certs { };
 
+    carton = callPackage ../development/ocaml-modules/carton { };
+
+    carton-git = callPackage ../development/ocaml-modules/carton/git.nix { };
+
+    carton-lwt = callPackage ../development/ocaml-modules/carton/lwt.nix {
+      git-binary = pkgs.git;
+    };
+
     camlidl = callPackage ../development/tools/ocaml/camlidl { };
 
     camlp4 =
···
 
     imagelib = callPackage ../development/ocaml-modules/imagelib { };
 
-    imagelib-unix = callPackage ../development/ocaml-modules/imagelib/unix.nix { };
-
     inotify = callPackage ../development/ocaml-modules/inotify { };
 
     integers = callPackage ../development/ocaml-modules/integers { };
···
       git-binary = pkgs.git;
     };
 
-    git-http = callPackage ../development/ocaml-modules/git-http { };
+    git-cohttp = callPackage ../development/ocaml-modules/git/cohttp.nix { };
 
-    git-unix = callPackage ../development/ocaml-modules/git-unix {
+    git-cohttp-unix = callPackage ../development/ocaml-modules/git/cohttp-unix.nix { };
+
+    git-cohttp-mirage = callPackage ../development/ocaml-modules/git/cohttp-mirage.nix { };
+
+    git-unix = callPackage ../development/ocaml-modules/git/unix.nix {
       git-binary = pkgs.git;
     };
 
···
 
     irmin-chunk = callPackage ../development/ocaml-modules/irmin/chunk.nix { };
 
+    irmin-containers = callPackage ../development/ocaml-modules/irmin/containers.nix { };
+
     irmin-fs = callPackage ../development/ocaml-modules/irmin/fs.nix { };
 
     irmin-git = callPackage ../development/ocaml-modules/irmin/git.nix { };
···
 
     irmin-http = callPackage ../development/ocaml-modules/irmin/http.nix { };
 
-    irmin-mem = callPackage ../development/ocaml-modules/irmin/mem.nix { };
+    irmin-layers = callPackage ../development/ocaml-modules/irmin/layers.nix { };
+
+    irmin-mirage = callPackage ../development/ocaml-modules/irmin/mirage.nix { };
+
+    irmin-mirage-git = callPackage ../development/ocaml-modules/irmin/mirage-git.nix { };
+
+    irmin-mirage-graphql = callPackage ../development/ocaml-modules/irmin/mirage-graphql.nix { };
 
     irmin-pack = callPackage ../development/ocaml-modules/irmin/pack.nix { };
 

pkgs/top-level/perl-packages.nix

···
       description = "Indent and reformat perl scripts";
       license = lib.licenses.gpl2Plus;
     };
+    nativeBuildInputs = lib.optional stdenv.isDarwin shortenPerlShebang;
+    postInstall = lib.optionalString stdenv.isDarwin ''
+      shortenPerlShebang $out/bin/perltidy
+    '';
   };
 
   PHPSerialization = buildPerlPackage {