diff --git a/flake.lock b/flake.lock
index 4299055f995a09f004cbf48da4c2d2065b2cdfa9..ede0825e1cbf8571a5d561e7ce8aa367a3b5c213 100644
--- a/flake.lock
+++ b/flake.lock
@@ -1,5 +1,22 @@
 {
   "nodes": {
+    "all-cabal-hashes": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1667742759,
+        "narHash": "sha256-PniFwhuGiX32rPHNyqgx8nn1No39SP89CHSoBuJOXlE=",
+        "owner": "commercialhaskell",
+        "repo": "all-cabal-hashes",
+        "rev": "eaf3b72978447f236e82c0de1d6f770e3dec00a7",
+        "type": "github"
+      },
+      "original": {
+        "owner": "commercialhaskell",
+        "ref": "hackage",
+        "repo": "all-cabal-hashes",
+        "type": "github"
+      }
+    },
     "flake-utils": {
       "locked": {
         "lastModified": 1659877975,
@@ -113,6 +130,7 @@
     },
     "root": {
       "inputs": {
+        "all-cabal-hashes": "all-cabal-hashes",
         "flake-utils": "flake-utils",
         "get-flake": "get-flake",
         "horizon-gen-nix": "horizon-gen-nix",
diff --git a/flake.nix b/flake.nix
index cd7514fc285630c073c0d45b08b97e11f3821425..e0e53520767a98e88833e8e67cec7846b16c8843 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1,5 +1,9 @@
 {
   inputs = {
+    all-cabal-hashes = {
+      url = "github:commercialhaskell/all-cabal-hashes/hackage";
+      flake = false;
+    };
     get-flake.url = "github:ursi/get-flake";
     lint-utils.url = "git+https://gitlab.homotopic.tech/nix/lint-utils";
     horizon-gen-nix = {
@@ -8,15 +12,19 @@
     };
     nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
   };
-  outputs = inputs@{ self, nixpkgs, flake-utils, get-flake, horizon-gen-nix, lint-utils, ... }:
+  outputs = inputs@{ self, all-cabal-hashes, nixpkgs, flake-utils, get-flake, horizon-gen-nix, lint-utils, ... }:
     flake-utils.lib.eachSystem [ "x86_64-linux" ] (system:
       let
         pkgs = import nixpkgs { inherit system; };
         horizon-gen-nix-app = get-flake horizon-gen-nix;
-        overrides-hp = import ./overlay.nix { inherit inputs pkgs; };
         configuration = import ./configuration.nix { inherit inputs pkgs; };
-        hp = pkgs.haskell.packages.ghc942.override {
-          overrides = pkgs.lib.composeManyExtensions [ overrides-hp configuration ];
+        hsPkgs = pkgs.callPackage (nixpkgs + /pkgs/development/haskell-modules) {
+          buildHaskellPackages = pkgs.haskell.packages.ghc942;
+          configurationCommon = { pkgs, haskellLib }: self: super: { };
+          ghc = pkgs.haskell.compiler.ghc942;
+          haskellLib = pkgs.haskell.lib;
+          initialPackages = import ./overlay.nix;
+          compilerConfig = pkgs.callPackage (nixpkgs + /pkgs/development/haskell-modules/configuration-ghc-9.4.x.nix) { haskellLib = pkgs.haskell.lib; };
         };
         hp' = pkgs.lib.filterAttrs
           (n: v: v != null
@@ -24,7 +32,7 @@
             && pkgs.lib.hasAttr "type" v
             && v.type == "derivation"
             && v.meta.broken == false)
-          hp;
+          hsPkgs;
         horizon-gen-gitlab-ci = pkgs.writers.writeBashBin "gen-gitlab-ci" "${pkgs.dhall-json}/bin/dhall-to-yaml --file .gitlab-ci.dhall";
       in
       {
@@ -39,7 +47,6 @@
           dhall-format = lint-utils.outputs.linters.x86_64-linux.dhall-format ./.;
           nixpkgs-fmt = lint-utils.outputs.linters.x86_64-linux.nixpkgs-fmt ./.;
         };
-        overrides.ghc942 = overrides-hp;
         packages = hp';
       });
 }
diff --git a/overlay.nix b/overlay.nix
index ba62a593e87121413bdd916c5f881acd6c01d137..39231e3a2d5fc59daf705da1166736665183b265 100644
--- a/overlay.nix
+++ b/overlay.nix
@@ -1,996 +1,996 @@
-{pkgs, ...}:
+{pkgs, lib, callPackage, ...}:
 
-final: prev: with pkgs.haskell.lib; {
-  Cabal = prev.callPackage (./pkgs/Cabal.nix) { };
+self: with pkgs.haskell.lib; {
+  Cabal = self.callPackage (./pkgs/Cabal.nix) { };
 
-  Cabal-QuickCheck = prev.callPackage (./pkgs/Cabal-QuickCheck.nix) { };
+  Cabal-QuickCheck = self.callPackage (./pkgs/Cabal-QuickCheck.nix) { };
 
-  Cabal-described = prev.callPackage (./pkgs/Cabal-described.nix) { };
+  Cabal-described = self.callPackage (./pkgs/Cabal-described.nix) { };
 
-  Cabal-syntax = prev.callPackage (./pkgs/Cabal-syntax.nix) { };
+  Cabal-syntax = self.callPackage (./pkgs/Cabal-syntax.nix) { };
 
-  Cabal-tree-diff = prev.callPackage (./pkgs/Cabal-tree-diff.nix) { };
+  Cabal-tree-diff = self.callPackage (./pkgs/Cabal-tree-diff.nix) { };
 
-  ChasingBottoms = prev.callPackage (./pkgs/ChasingBottoms.nix) { };
+  ChasingBottoms = self.callPackage (./pkgs/ChasingBottoms.nix) { };
 
-  HTTP = prev.callPackage (./pkgs/HTTP.nix) { };
+  HTTP = self.callPackage (./pkgs/HTTP.nix) { };
 
-  JuicyPixels = prev.callPackage (./pkgs/JuicyPixels.nix) { };
+  JuicyPixels = self.callPackage (./pkgs/JuicyPixels.nix) { };
 
-  MonadRandom = prev.callPackage (./pkgs/MonadRandom.nix) { };
+  MonadRandom = self.callPackage (./pkgs/MonadRandom.nix) { };
 
-  OneTuple = prev.callPackage (./pkgs/OneTuple.nix) { };
+  OneTuple = self.callPackage (./pkgs/OneTuple.nix) { };
 
-  OpenGLRaw = prev.callPackage (./pkgs/OpenGLRaw.nix) { };
+  OpenGLRaw = self.callPackage (./pkgs/OpenGLRaw.nix) { };
 
-  PyF = prev.callPackage (./pkgs/PyF.nix) { };
+  PyF = self.callPackage (./pkgs/PyF.nix) { };
 
-  adjunctions = prev.callPackage (./pkgs/adjunctions.nix) { };
+  adjunctions = self.callPackage (./pkgs/adjunctions.nix) { };
 
-  aeson = prev.callPackage (./pkgs/aeson.nix) { };
+  aeson = self.callPackage (./pkgs/aeson.nix) { };
 
-  aeson-pretty = prev.callPackage (./pkgs/aeson-pretty.nix) { };
+  aeson-pretty = self.callPackage (./pkgs/aeson-pretty.nix) { };
 
-  aeson-yaml = prev.callPackage (./pkgs/aeson-yaml.nix) { };
+  aeson-yaml = self.callPackage (./pkgs/aeson-yaml.nix) { };
 
-  ansi-terminal = prev.callPackage (./pkgs/ansi-terminal.nix) { };
+  ansi-terminal = self.callPackage (./pkgs/ansi-terminal.nix) { };
 
-  ansi-wl-pprint = prev.callPackage (./pkgs/ansi-wl-pprint.nix) { };
+  ansi-wl-pprint = self.callPackage (./pkgs/ansi-wl-pprint.nix) { };
 
-  apecs = prev.callPackage (./pkgs/apecs.nix) { };
+  apecs = self.callPackage (./pkgs/apecs.nix) { };
 
-  asn1-encoding = prev.callPackage (./pkgs/asn1-encoding.nix) { };
+  asn1-encoding = self.callPackage (./pkgs/asn1-encoding.nix) { };
 
-  asn1-parse = prev.callPackage (./pkgs/asn1-parse.nix) { };
+  asn1-parse = self.callPackage (./pkgs/asn1-parse.nix) { };
 
-  asn1-types = prev.callPackage (./pkgs/asn1-types.nix) { };
+  asn1-types = self.callPackage (./pkgs/asn1-types.nix) { };
 
-  assoc = prev.callPackage (./pkgs/assoc.nix) { };
+  assoc = self.callPackage (./pkgs/assoc.nix) { };
 
-  async = prev.callPackage (./pkgs/async.nix) { };
+  async = self.callPackage (./pkgs/async.nix) { };
 
-  atomic-primops = prev.callPackage (./pkgs/atomic-primops.nix) { };
+  atomic-primops = self.callPackage (./pkgs/atomic-primops.nix) { };
 
-  attoparsec = prev.callPackage (./pkgs/attoparsec.nix) { };
+  attoparsec = self.callPackage (./pkgs/attoparsec.nix) { };
 
-  attoparsec-binary = prev.callPackage (./pkgs/attoparsec-binary.nix) { };
+  attoparsec-binary = self.callPackage (./pkgs/attoparsec-binary.nix) { };
 
-  attoparsec-iso8601 = prev.callPackage (./pkgs/attoparsec-iso8601.nix) { };
+  attoparsec-iso8601 = self.callPackage (./pkgs/attoparsec-iso8601.nix) { };
 
-  autodocodec = prev.callPackage (./pkgs/autodocodec.nix) { };
+  autodocodec = self.callPackage (./pkgs/autodocodec.nix) { };
 
-  autodocodec-schema = prev.callPackage (./pkgs/autodocodec-schema.nix) { };
+  autodocodec-schema = self.callPackage (./pkgs/autodocodec-schema.nix) { };
 
-  autodocodec-servant-multipart = prev.callPackage (./pkgs/autodocodec-servant-multipart.nix) { };
+  autodocodec-servant-multipart = self.callPackage (./pkgs/autodocodec-servant-multipart.nix) { };
 
-  autodocodec-yaml = prev.callPackage (./pkgs/autodocodec-yaml.nix) { };
+  autodocodec-yaml = self.callPackage (./pkgs/autodocodec-yaml.nix) { };
 
-  barbies = prev.callPackage (./pkgs/barbies.nix) { };
+  barbies = self.callPackage (./pkgs/barbies.nix) { };
 
-  base-compat = prev.callPackage (./pkgs/base-compat.nix) { };
+  base-compat = self.callPackage (./pkgs/base-compat.nix) { };
 
-  base-compat-batteries = prev.callPackage (./pkgs/base-compat-batteries.nix) { };
+  base-compat-batteries = self.callPackage (./pkgs/base-compat-batteries.nix) { };
 
-  base64 = prev.callPackage (./pkgs/base64.nix) { };
+  base64 = self.callPackage (./pkgs/base64.nix) { };
 
-  basement = prev.callPackage (./pkgs/basement.nix) { };
+  basement = self.callPackage (./pkgs/basement.nix) { };
 
-  bifunctors = prev.callPackage (./pkgs/bifunctors.nix) { };
+  bifunctors = self.callPackage (./pkgs/bifunctors.nix) { };
 
-  bimap = prev.callPackage (./pkgs/bimap.nix) { };
+  bimap = self.callPackage (./pkgs/bimap.nix) { };
 
-  binary-orphans = prev.callPackage (./pkgs/binary-orphans.nix) { };
+  binary-orphans = self.callPackage (./pkgs/binary-orphans.nix) { };
 
-  bitvec = prev.callPackage (./pkgs/bitvec.nix) { };
+  bitvec = self.callPackage (./pkgs/bitvec.nix) { };
 
-  blaze-html = prev.callPackage (./pkgs/blaze-html.nix) { };
+  blaze-html = self.callPackage (./pkgs/blaze-html.nix) { };
 
-  blaze-markup = prev.callPackage (./pkgs/blaze-markup.nix) { };
+  blaze-markup = self.callPackage (./pkgs/blaze-markup.nix) { };
 
-  blaze-textual = prev.callPackage (./pkgs/blaze-textual.nix) { };
+  blaze-textual = self.callPackage (./pkgs/blaze-textual.nix) { };
 
-  boring = prev.callPackage (./pkgs/boring.nix) { };
+  boring = self.callPackage (./pkgs/boring.nix) { };
 
-  breakpoint = prev.callPackage (./pkgs/breakpoint.nix) { };
+  breakpoint = self.callPackage (./pkgs/breakpoint.nix) { };
 
-  brick = prev.callPackage (./pkgs/brick.nix) { };
+  brick = self.callPackage (./pkgs/brick.nix) { };
 
-  bsb-http-chunked = prev.callPackage (./pkgs/bsb-http-chunked.nix) { };
+  bsb-http-chunked = self.callPackage (./pkgs/bsb-http-chunked.nix) { };
 
-  bytes = prev.callPackage (./pkgs/bytes.nix) { };
+  bytes = self.callPackage (./pkgs/bytes.nix) { };
 
-  cabal-doctest = prev.callPackage (./pkgs/cabal-doctest.nix) { };
+  cabal-doctest = self.callPackage (./pkgs/cabal-doctest.nix) { };
 
-  cabal-install = prev.callPackage (./pkgs/cabal-install.nix) { };
+  cabal-install = self.callPackage (./pkgs/cabal-install.nix) { };
 
-  cabal-install-solver = prev.callPackage (./pkgs/cabal-install-solver.nix) { };
+  cabal-install-solver = self.callPackage (./pkgs/cabal-install-solver.nix) { };
 
-  cabal2nix = prev.callPackage (./pkgs/cabal2nix.nix) { };
+  cabal2nix = self.callPackage (./pkgs/cabal2nix.nix) { };
 
-  cache = prev.callPackage (./pkgs/cache.nix) { };
+  cache = self.callPackage (./pkgs/cache.nix) { };
 
-  case-insensitive = prev.callPackage (./pkgs/case-insensitive.nix) { };
+  case-insensitive = self.callPackage (./pkgs/case-insensitive.nix) { };
 
-  cassava = prev.callPackage (./pkgs/cassava.nix) { };
+  cassava = self.callPackage (./pkgs/cassava.nix) { };
 
-  cassava-megaparsec = prev.callPackage (./pkgs/cassava-megaparsec.nix) { };
+  cassava-megaparsec = self.callPackage (./pkgs/cassava-megaparsec.nix) { };
 
-  cborg = prev.callPackage (./pkgs/cborg.nix) { };
+  cborg = self.callPackage (./pkgs/cborg.nix) { };
 
-  cborg-json = prev.callPackage (./pkgs/cborg-json.nix) { };
+  cborg-json = self.callPackage (./pkgs/cborg-json.nix) { };
 
-  cereal = prev.callPackage (./pkgs/cereal.nix) { };
+  cereal = self.callPackage (./pkgs/cereal.nix) { };
 
-  charset = prev.callPackage (./pkgs/charset.nix) { };
+  charset = self.callPackage (./pkgs/charset.nix) { };
 
-  citeproc = prev.callPackage (./pkgs/citeproc.nix) { };
+  citeproc = self.callPackage (./pkgs/citeproc.nix) { };
 
-  co-log-core = prev.callPackage (./pkgs/co-log-core.nix) { };
+  co-log-core = self.callPackage (./pkgs/co-log-core.nix) { };
 
-  co-log-polysemy = prev.callPackage (./pkgs/co-log-polysemy.nix) { };
+  co-log-polysemy = self.callPackage (./pkgs/co-log-polysemy.nix) { };
 
-  colourista = prev.callPackage (./pkgs/colourista.nix) { };
+  colourista = self.callPackage (./pkgs/colourista.nix) { };
 
-  commonmark = prev.callPackage (./pkgs/commonmark.nix) { };
+  commonmark = self.callPackage (./pkgs/commonmark.nix) { };
 
-  commonmark-extensions = prev.callPackage (./pkgs/commonmark-extensions.nix) { };
+  commonmark-extensions = self.callPackage (./pkgs/commonmark-extensions.nix) { };
 
-  commonmark-pandoc = prev.callPackage (./pkgs/commonmark-pandoc.nix) { };
+  commonmark-pandoc = self.callPackage (./pkgs/commonmark-pandoc.nix) { };
 
-  comonad = prev.callPackage (./pkgs/comonad.nix) { };
+  comonad = self.callPackage (./pkgs/comonad.nix) { };
 
-  compact = prev.callPackage (./pkgs/compact.nix) { };
+  compact = self.callPackage (./pkgs/compact.nix) { };
 
-  compactable = prev.callPackage (./pkgs/compactable.nix) { };
+  compactable = self.callPackage (./pkgs/compactable.nix) { };
 
-  composite-base = prev.callPackage (./pkgs/composite-base.nix) { };
+  composite-base = self.callPackage (./pkgs/composite-base.nix) { };
 
-  composite-cassava = prev.callPackage (./pkgs/composite-cassava.nix) { };
+  composite-cassava = self.callPackage (./pkgs/composite-cassava.nix) { };
 
-  composite-dhall = prev.callPackage (./pkgs/composite-dhall.nix) { };
+  composite-dhall = self.callPackage (./pkgs/composite-dhall.nix) { };
 
-  composite-lens-extra = prev.callPackage (./pkgs/composite-lens-extra.nix) { };
+  composite-lens-extra = self.callPackage (./pkgs/composite-lens-extra.nix) { };
 
-  composite-tuple = prev.callPackage (./pkgs/composite-tuple.nix) { };
+  composite-tuple = self.callPackage (./pkgs/composite-tuple.nix) { };
 
-  concurrent-output = prev.callPackage (./pkgs/concurrent-output.nix) { };
+  concurrent-output = self.callPackage (./pkgs/concurrent-output.nix) { };
 
-  conduit = prev.callPackage (./pkgs/conduit.nix) { };
+  conduit = self.callPackage (./pkgs/conduit.nix) { };
 
-  conduit-extra = prev.callPackage (./pkgs/conduit-extra.nix) { };
+  conduit-extra = self.callPackage (./pkgs/conduit-extra.nix) { };
 
-  config-ini = prev.callPackage (./pkgs/config-ini.nix) { };
+  config-ini = self.callPackage (./pkgs/config-ini.nix) { };
 
-  connection = prev.callPackage (./pkgs/connection.nix) { };
+  connection = self.callPackage (./pkgs/connection.nix) { };
 
-  constraints = prev.callPackage (./pkgs/constraints.nix) { };
+  constraints = self.callPackage (./pkgs/constraints.nix) { };
 
-  criterion = prev.callPackage (./pkgs/criterion.nix) { };
+  criterion = self.callPackage (./pkgs/criterion.nix) { };
 
-  criterion-measurement = prev.callPackage (./pkgs/criterion-measurement.nix) { };
+  criterion-measurement = self.callPackage (./pkgs/criterion-measurement.nix) { };
 
-  cryptohash = prev.callPackage (./pkgs/cryptohash.nix) { };
+  cryptohash = self.callPackage (./pkgs/cryptohash.nix) { };
 
-  cryptohash-sha1 = prev.callPackage (./pkgs/cryptohash-sha1.nix) { };
+  cryptohash-sha1 = self.callPackage (./pkgs/cryptohash-sha1.nix) { };
 
-  cryptonite = prev.callPackage (./pkgs/cryptonite.nix) { };
+  cryptonite = self.callPackage (./pkgs/cryptonite.nix) { };
 
-  cursor = prev.callPackage (./pkgs/cursor.nix) { };
+  cursor = self.callPackage (./pkgs/cursor.nix) { };
 
-  cursor-brick = prev.callPackage (./pkgs/cursor-brick.nix) { };
+  cursor-brick = self.callPackage (./pkgs/cursor-brick.nix) { };
 
-  cursor-dirforest = prev.callPackage (./pkgs/cursor-dirforest.nix) { };
+  cursor-dirforest = self.callPackage (./pkgs/cursor-dirforest.nix) { };
 
-  cursor-dirforest-brick = prev.callPackage (./pkgs/cursor-dirforest-brick.nix) { };
+  cursor-dirforest-brick = self.callPackage (./pkgs/cursor-dirforest-brick.nix) { };
 
-  cursor-dirforest-gen = prev.callPackage (./pkgs/cursor-dirforest-gen.nix) { };
+  cursor-dirforest-gen = self.callPackage (./pkgs/cursor-dirforest-gen.nix) { };
 
-  cursor-gen = prev.callPackage (./pkgs/cursor-gen.nix) { };
+  cursor-gen = self.callPackage (./pkgs/cursor-gen.nix) { };
 
-  daemons = prev.callPackage (./pkgs/daemons.nix) { };
+  daemons = self.callPackage (./pkgs/daemons.nix) { };
 
-  data-fix = prev.callPackage (./pkgs/data-fix.nix) { };
+  data-fix = self.callPackage (./pkgs/data-fix.nix) { };
 
-  data-sketches = prev.callPackage (./pkgs/data-sketches.nix) { };
+  data-sketches = self.callPackage (./pkgs/data-sketches.nix) { };
 
-  data-sketches-core = prev.callPackage (./pkgs/data-sketches-core.nix) { };
+  data-sketches-core = self.callPackage (./pkgs/data-sketches-core.nix) { };
 
-  dec = prev.callPackage (./pkgs/dec.nix) { };
+  dec = self.callPackage (./pkgs/dec.nix) { };
 
-  dense-linear-algebra = prev.callPackage (./pkgs/dense-linear-algebra.nix) { };
+  dense-linear-algebra = self.callPackage (./pkgs/dense-linear-algebra.nix) { };
 
-  deriving-aeson = prev.callPackage (./pkgs/deriving-aeson.nix) { };
+  deriving-aeson = self.callPackage (./pkgs/deriving-aeson.nix) { };
 
-  dhall = prev.callPackage (./pkgs/dhall.nix) { };
+  dhall = self.callPackage (./pkgs/dhall.nix) { };
 
-  dhall-json = prev.callPackage (./pkgs/dhall-json.nix) { };
+  dhall-json = self.callPackage (./pkgs/dhall-json.nix) { };
 
-  dimensional = prev.callPackage (./pkgs/dimensional.nix) { };
+  dimensional = self.callPackage (./pkgs/dimensional.nix) { };
 
-  dirforest = prev.callPackage (./pkgs/dirforest.nix) { };
+  dirforest = self.callPackage (./pkgs/dirforest.nix) { };
 
-  distribution-nixpkgs = prev.callPackage (./pkgs/distribution-nixpkgs.nix) { };
+  distribution-nixpkgs = self.callPackage (./pkgs/distribution-nixpkgs.nix) { };
 
-  distributive = prev.callPackage (./pkgs/distributive.nix) { };
+  distributive = self.callPackage (./pkgs/distributive.nix) { };
 
-  doctemplates = prev.callPackage (./pkgs/doctemplates.nix) { };
+  doctemplates = self.callPackage (./pkgs/doctemplates.nix) { };
 
-  doctest = prev.callPackage (./pkgs/doctest.nix) { };
+  doctest = self.callPackage (./pkgs/doctest.nix) { };
 
-  doctest-parallel = prev.callPackage (./pkgs/doctest-parallel.nix) { };
+  doctest-parallel = self.callPackage (./pkgs/doctest-parallel.nix) { };
 
-  double-conversion = prev.callPackage (./pkgs/double-conversion.nix) { };
+  double-conversion = self.callPackage (./pkgs/double-conversion.nix) { };
 
-  ed25519 = prev.callPackage (./pkgs/ed25519.nix) { };
+  ed25519 = self.callPackage (./pkgs/ed25519.nix) { };
 
-  effectful = prev.callPackage (./pkgs/effectful.nix) { };
+  effectful = self.callPackage (./pkgs/effectful.nix) { };
 
-  effectful-cache = prev.callPackage (./pkgs/effectful-cache.nix) { };
+  effectful-cache = self.callPackage (./pkgs/effectful-cache.nix) { };
 
-  effectful-core = prev.callPackage (./pkgs/effectful-core.nix) { };
+  effectful-core = self.callPackage (./pkgs/effectful-core.nix) { };
 
-  effectful-th = prev.callPackage (./pkgs/effectful-th.nix) { };
+  effectful-th = self.callPackage (./pkgs/effectful-th.nix) { };
 
-  either = prev.callPackage (./pkgs/either.nix) { };
+  either = self.callPackage (./pkgs/either.nix) { };
 
-  email-validate = prev.callPackage (./pkgs/email-validate.nix) { };
+  email-validate = self.callPackage (./pkgs/email-validate.nix) { };
 
-  enclosed-exceptions = prev.callPackage (./pkgs/enclosed-exceptions.nix) { };
+  enclosed-exceptions = self.callPackage (./pkgs/enclosed-exceptions.nix) { };
 
-  expiring-cache-map = prev.callPackage (./pkgs/expiring-cache-map.nix) { };
+  expiring-cache-map = self.callPackage (./pkgs/expiring-cache-map.nix) { };
 
-  extra = prev.callPackage (./pkgs/extra.nix) { };
+  extra = self.callPackage (./pkgs/extra.nix) { };
 
-  fcf-containers = prev.callPackage (./pkgs/fcf-containers.nix) { };
+  fcf-containers = self.callPackage (./pkgs/fcf-containers.nix) { };
 
-  filepattern = prev.callPackage (./pkgs/filepattern.nix) { };
+  filepattern = self.callPackage (./pkgs/filepattern.nix) { };
 
-  fin = prev.callPackage (./pkgs/fin.nix) { };
+  fin = self.callPackage (./pkgs/fin.nix) { };
 
-  finite-field = prev.callPackage (./pkgs/finite-field.nix) { };
+  finite-field = self.callPackage (./pkgs/finite-field.nix) { };
 
-  first-class-families = prev.callPackage (./pkgs/first-class-families.nix) { };
+  first-class-families = self.callPackage (./pkgs/first-class-families.nix) { };
 
-  foldl = prev.callPackage (./pkgs/foldl.nix) { };
+  foldl = self.callPackage (./pkgs/foldl.nix) { };
 
-  foundation = prev.callPackage (./pkgs/foundation.nix) { };
+  foundation = self.callPackage (./pkgs/foundation.nix) { };
 
-  free = prev.callPackage (./pkgs/free.nix) { };
+  free = self.callPackage (./pkgs/free.nix) { };
 
-  fsnotify = prev.callPackage (./pkgs/fsnotify.nix) { };
+  fsnotify = self.callPackage (./pkgs/fsnotify.nix) { };
 
-  fuzzy-time = prev.callPackage (./pkgs/fuzzy-time.nix) { };
+  fuzzy-time = self.callPackage (./pkgs/fuzzy-time.nix) { };
 
-  generic-lens-core = prev.callPackage (./pkgs/generic-lens-core.nix) { };
+  generic-lens-core = self.callPackage (./pkgs/generic-lens-core.nix) { };
 
-  generic-lens-lite = prev.callPackage (./pkgs/generic-lens-lite.nix) { };
+  generic-lens-lite = self.callPackage (./pkgs/generic-lens-lite.nix) { };
 
-  generic-monoid = prev.callPackage (./pkgs/generic-monoid.nix) { };
+  generic-monoid = self.callPackage (./pkgs/generic-monoid.nix) { };
 
-  generic-optics = prev.callPackage (./pkgs/generic-optics.nix) { };
+  generic-optics = self.callPackage (./pkgs/generic-optics.nix) { };
 
-  generic-optics-lite = prev.callPackage (./pkgs/generic-optics-lite.nix) { };
+  generic-optics-lite = self.callPackage (./pkgs/generic-optics-lite.nix) { };
 
-  generics-sop = prev.callPackage (./pkgs/generics-sop.nix) { };
+  generics-sop = self.callPackage (./pkgs/generics-sop.nix) { };
 
-  genvalidity = prev.callPackage (./pkgs/genvalidity.nix) { };
+  genvalidity = self.callPackage (./pkgs/genvalidity.nix) { };
 
-  genvalidity-aeson = prev.callPackage (./pkgs/genvalidity-aeson.nix) { };
+  genvalidity-aeson = self.callPackage (./pkgs/genvalidity-aeson.nix) { };
 
-  genvalidity-bytestring = prev.callPackage (./pkgs/genvalidity-bytestring.nix) { };
+  genvalidity-bytestring = self.callPackage (./pkgs/genvalidity-bytestring.nix) { };
 
-  genvalidity-case-insensitive = prev.callPackage (./pkgs/genvalidity-case-insensitive.nix) { };
+  genvalidity-case-insensitive = self.callPackage (./pkgs/genvalidity-case-insensitive.nix) { };
 
-  genvalidity-containers = prev.callPackage (./pkgs/genvalidity-containers.nix) { };
+  genvalidity-containers = self.callPackage (./pkgs/genvalidity-containers.nix) { };
 
-  genvalidity-criterion = prev.callPackage (./pkgs/genvalidity-criterion.nix) { };
+  genvalidity-criterion = self.callPackage (./pkgs/genvalidity-criterion.nix) { };
 
-  genvalidity-dirforest = prev.callPackage (./pkgs/genvalidity-dirforest.nix) { };
+  genvalidity-dirforest = self.callPackage (./pkgs/genvalidity-dirforest.nix) { };
 
-  genvalidity-hspec = prev.callPackage (./pkgs/genvalidity-hspec.nix) { };
+  genvalidity-hspec = self.callPackage (./pkgs/genvalidity-hspec.nix) { };
 
-  genvalidity-hspec-optics = prev.callPackage (./pkgs/genvalidity-hspec-optics.nix) { };
+  genvalidity-hspec-optics = self.callPackage (./pkgs/genvalidity-hspec-optics.nix) { };
 
-  genvalidity-path = prev.callPackage (./pkgs/genvalidity-path.nix) { };
+  genvalidity-path = self.callPackage (./pkgs/genvalidity-path.nix) { };
 
-  genvalidity-persistent = prev.callPackage (./pkgs/genvalidity-persistent.nix) { };
+  genvalidity-persistent = self.callPackage (./pkgs/genvalidity-persistent.nix) { };
 
-  genvalidity-property = prev.callPackage (./pkgs/genvalidity-property.nix) { };
+  genvalidity-property = self.callPackage (./pkgs/genvalidity-property.nix) { };
 
-  genvalidity-scientific = prev.callPackage (./pkgs/genvalidity-scientific.nix) { };
+  genvalidity-scientific = self.callPackage (./pkgs/genvalidity-scientific.nix) { };
 
-  genvalidity-sydtest = prev.callPackage (./pkgs/genvalidity-sydtest.nix) { };
+  genvalidity-sydtest = self.callPackage (./pkgs/genvalidity-sydtest.nix) { };
 
-  genvalidity-sydtest-aeson = prev.callPackage (./pkgs/genvalidity-sydtest-aeson.nix) { };
+  genvalidity-sydtest-aeson = self.callPackage (./pkgs/genvalidity-sydtest-aeson.nix) { };
 
-  genvalidity-sydtest-hashable = prev.callPackage (./pkgs/genvalidity-sydtest-hashable.nix) { };
+  genvalidity-sydtest-hashable = self.callPackage (./pkgs/genvalidity-sydtest-hashable.nix) { };
 
-  genvalidity-sydtest-lens = prev.callPackage (./pkgs/genvalidity-sydtest-lens.nix) { };
+  genvalidity-sydtest-lens = self.callPackage (./pkgs/genvalidity-sydtest-lens.nix) { };
 
-  genvalidity-sydtest-persistent = prev.callPackage (./pkgs/genvalidity-sydtest-persistent.nix) { };
+  genvalidity-sydtest-persistent = self.callPackage (./pkgs/genvalidity-sydtest-persistent.nix) { };
 
-  genvalidity-text = prev.callPackage (./pkgs/genvalidity-text.nix) { };
+  genvalidity-text = self.callPackage (./pkgs/genvalidity-text.nix) { };
 
-  genvalidity-time = prev.callPackage (./pkgs/genvalidity-time.nix) { };
+  genvalidity-time = self.callPackage (./pkgs/genvalidity-time.nix) { };
 
-  genvalidity-unordered-containers = prev.callPackage (./pkgs/genvalidity-unordered-containers.nix) { };
+  genvalidity-unordered-containers = self.callPackage (./pkgs/genvalidity-unordered-containers.nix) { };
 
-  genvalidity-uuid = prev.callPackage (./pkgs/genvalidity-uuid.nix) { };
+  genvalidity-uuid = self.callPackage (./pkgs/genvalidity-uuid.nix) { };
 
-  genvalidity-vector = prev.callPackage (./pkgs/genvalidity-vector.nix) { };
+  genvalidity-vector = self.callPackage (./pkgs/genvalidity-vector.nix) { };
 
-  ghc-byteorder = prev.callPackage (./pkgs/ghc-byteorder.nix) { };
+  ghc-byteorder = self.callPackage (./pkgs/ghc-byteorder.nix) { };
 
-  ghc-check = prev.callPackage (./pkgs/ghc-check.nix) { };
+  ghc-check = self.callPackage (./pkgs/ghc-check.nix) { };
 
-  ghc-exactprint = prev.callPackage (./pkgs/ghc-exactprint.nix) { };
+  ghc-exactprint = self.callPackage (./pkgs/ghc-exactprint.nix) { };
 
-  ghc-lib-parser = prev.callPackage (./pkgs/ghc-lib-parser.nix) { };
+  ghc-lib-parser = self.callPackage (./pkgs/ghc-lib-parser.nix) { };
 
-  ghc-lib-parser-ex = prev.callPackage (./pkgs/ghc-lib-parser-ex.nix) { };
+  ghc-lib-parser-ex = self.callPackage (./pkgs/ghc-lib-parser-ex.nix) { };
 
-  ghc-paths = prev.callPackage (./pkgs/ghc-paths.nix) { };
+  ghc-paths = self.callPackage (./pkgs/ghc-paths.nix) { };
 
-  ghc-tcplugins-extra = prev.callPackage (./pkgs/ghc-tcplugins-extra.nix) { };
+  ghc-tcplugins-extra = self.callPackage (./pkgs/ghc-tcplugins-extra.nix) { };
 
-  ghc-typelits-knownnat = prev.callPackage (./pkgs/ghc-typelits-knownnat.nix) { };
+  ghc-typelits-knownnat = self.callPackage (./pkgs/ghc-typelits-knownnat.nix) { };
 
-  ghc-typelits-natnormalise = prev.callPackage (./pkgs/ghc-typelits-natnormalise.nix) { };
+  ghc-typelits-natnormalise = self.callPackage (./pkgs/ghc-typelits-natnormalise.nix) { };
 
-  ghcid = prev.callPackage (./pkgs/ghcid.nix) { };
+  ghcid = self.callPackage (./pkgs/ghcid.nix) { };
 
-  gitrev = prev.callPackage (./pkgs/gitrev.nix) { };
+  gitrev = self.callPackage (./pkgs/gitrev.nix) { };
 
-  hackage-db = prev.callPackage (./pkgs/hackage-db.nix) { };
+  hackage-db = self.callPackage (./pkgs/hackage-db.nix) { };
 
-  hackage-security = prev.callPackage (./pkgs/hackage-security.nix) { };
+  hackage-security = self.callPackage (./pkgs/hackage-security.nix) { };
 
-  haddock-library = prev.callPackage (./pkgs/haddock-library.nix) { };
+  haddock-library = self.callPackage (./pkgs/haddock-library.nix) { };
 
-  hashable = prev.callPackage (./pkgs/hashable.nix) { };
+  hashable = self.callPackage (./pkgs/hashable.nix) { };
 
-  hashing = prev.callPackage (./pkgs/hashing.nix) { };
+  hashing = self.callPackage (./pkgs/hashing.nix) { };
 
-  hashtables = prev.callPackage (./pkgs/hashtables.nix) { };
+  hashtables = self.callPackage (./pkgs/hashtables.nix) { };
 
-  haskell-src-meta = prev.callPackage (./pkgs/haskell-src-meta.nix) { };
+  haskell-src-meta = self.callPackage (./pkgs/haskell-src-meta.nix) { };
 
-  hedgehog = prev.callPackage (./pkgs/hedgehog.nix) { };
+  hedgehog = self.callPackage (./pkgs/hedgehog.nix) { };
 
-  hedgehog-golden = prev.callPackage (./pkgs/hedgehog-golden.nix) { };
+  hedgehog-golden = self.callPackage (./pkgs/hedgehog-golden.nix) { };
 
-  hie-bios = prev.callPackage (./pkgs/hie-bios.nix) { };
+  hie-bios = self.callPackage (./pkgs/hie-bios.nix) { };
 
-  hie-compat = prev.callPackage (./pkgs/hie-compat.nix) { };
+  hie-compat = self.callPackage (./pkgs/hie-compat.nix) { };
 
-  hiedb = prev.callPackage (./pkgs/hiedb.nix) { };
+  hiedb = self.callPackage (./pkgs/hiedb.nix) { };
 
-  hinotify = prev.callPackage (./pkgs/hinotify.nix) { };
+  hinotify = self.callPackage (./pkgs/hinotify.nix) { };
 
-  hledger = prev.callPackage (./pkgs/hledger.nix) { };
+  hledger = self.callPackage (./pkgs/hledger.nix) { };
 
-  hledger-lib = prev.callPackage (./pkgs/hledger-lib.nix) { };
+  hledger-lib = self.callPackage (./pkgs/hledger-lib.nix) { };
 
-  hlint = prev.callPackage (./pkgs/hlint.nix) { };
+  hlint = self.callPackage (./pkgs/hlint.nix) { };
 
-  horizon-gen-nix = prev.callPackage (./pkgs/horizon-gen-nix.nix) { };
+  horizon-gen-nix = self.callPackage (./pkgs/horizon-gen-nix.nix) { };
 
-  hosc = prev.callPackage (./pkgs/hosc.nix) { };
+  hosc = self.callPackage (./pkgs/hosc.nix) { };
 
-  hourglass = prev.callPackage (./pkgs/hourglass.nix) { };
+  hourglass = self.callPackage (./pkgs/hourglass.nix) { };
 
-  hpack = prev.callPackage (./pkgs/hpack.nix) { };
+  hpack = self.callPackage (./pkgs/hpack.nix) { };
 
-  hpack-dhall = prev.callPackage (./pkgs/hpack-dhall.nix) { };
+  hpack-dhall = self.callPackage (./pkgs/hpack-dhall.nix) { };
 
-  hslua = prev.callPackage (./pkgs/hslua.nix) { };
+  hslua = self.callPackage (./pkgs/hslua.nix) { };
 
-  hslua-aeson = prev.callPackage (./pkgs/hslua-aeson.nix) { };
+  hslua-aeson = self.callPackage (./pkgs/hslua-aeson.nix) { };
 
-  hslua-classes = prev.callPackage (./pkgs/hslua-classes.nix) { };
+  hslua-classes = self.callPackage (./pkgs/hslua-classes.nix) { };
 
-  hslua-core = prev.callPackage (./pkgs/hslua-core.nix) { };
+  hslua-core = self.callPackage (./pkgs/hslua-core.nix) { };
 
-  hslua-marshalling = prev.callPackage (./pkgs/hslua-marshalling.nix) { };
+  hslua-marshalling = self.callPackage (./pkgs/hslua-marshalling.nix) { };
 
-  hslua-module-doclayout = prev.callPackage (./pkgs/hslua-module-doclayout.nix) { };
+  hslua-module-doclayout = self.callPackage (./pkgs/hslua-module-doclayout.nix) { };
 
-  hslua-module-path = prev.callPackage (./pkgs/hslua-module-path.nix) { };
+  hslua-module-path = self.callPackage (./pkgs/hslua-module-path.nix) { };
 
-  hslua-module-system = prev.callPackage (./pkgs/hslua-module-system.nix) { };
+  hslua-module-system = self.callPackage (./pkgs/hslua-module-system.nix) { };
 
-  hslua-module-text = prev.callPackage (./pkgs/hslua-module-text.nix) { };
+  hslua-module-text = self.callPackage (./pkgs/hslua-module-text.nix) { };
 
-  hslua-module-version = prev.callPackage (./pkgs/hslua-module-version.nix) { };
+  hslua-module-version = self.callPackage (./pkgs/hslua-module-version.nix) { };
 
-  hslua-objectorientation = prev.callPackage (./pkgs/hslua-objectorientation.nix) { };
+  hslua-objectorientation = self.callPackage (./pkgs/hslua-objectorientation.nix) { };
 
-  hslua-packaging = prev.callPackage (./pkgs/hslua-packaging.nix) { };
+  hslua-packaging = self.callPackage (./pkgs/hslua-packaging.nix) { };
 
-  hspec = prev.callPackage (./pkgs/hspec.nix) { };
+  hspec = self.callPackage (./pkgs/hspec.nix) { };
 
-  hspec-contrib = prev.callPackage (./pkgs/hspec-contrib.nix) { };
+  hspec-contrib = self.callPackage (./pkgs/hspec-contrib.nix) { };
 
-  hspec-core = prev.callPackage (./pkgs/hspec-core.nix) { };
+  hspec-core = self.callPackage (./pkgs/hspec-core.nix) { };
 
-  hspec-discover = prev.callPackage (./pkgs/hspec-discover.nix) { };
+  hspec-discover = self.callPackage (./pkgs/hspec-discover.nix) { };
 
-  hspec-meta = prev.callPackage (./pkgs/hspec-meta.nix) { };
+  hspec-meta = self.callPackage (./pkgs/hspec-meta.nix) { };
 
-  http-api-data = prev.callPackage (./pkgs/http-api-data.nix) { };
+  http-api-data = self.callPackage (./pkgs/http-api-data.nix) { };
 
-  http-client = prev.callPackage (./pkgs/http-client.nix) { };
+  http-client = self.callPackage (./pkgs/http-client.nix) { };
 
-  http-client-tls = prev.callPackage (./pkgs/http-client-tls.nix) { };
+  http-client-tls = self.callPackage (./pkgs/http-client-tls.nix) { };
 
-  http-date = prev.callPackage (./pkgs/http-date.nix) { };
+  http-date = self.callPackage (./pkgs/http-date.nix) { };
 
-  http-media = prev.callPackage (./pkgs/http-media.nix) { };
+  http-media = self.callPackage (./pkgs/http-media.nix) { };
 
-  http-types = prev.callPackage (./pkgs/http-types.nix) { };
+  http-types = self.callPackage (./pkgs/http-types.nix) { };
 
-  http2 = prev.callPackage (./pkgs/http2.nix) { };
+  http2 = self.callPackage (./pkgs/http2.nix) { };
 
-  incipit-base = prev.callPackage (./pkgs/incipit-base.nix) { };
+  incipit-base = self.callPackage (./pkgs/incipit-base.nix) { };
 
-  incipit-core = prev.callPackage (./pkgs/incipit-core.nix) { };
+  incipit-core = self.callPackage (./pkgs/incipit-core.nix) { };
 
-  indexed-traversable = prev.callPackage (./pkgs/indexed-traversable.nix) { };
+  indexed-traversable = self.callPackage (./pkgs/indexed-traversable.nix) { };
 
-  indexed-traversable-instances = prev.callPackage (./pkgs/indexed-traversable-instances.nix) { };
+  indexed-traversable-instances = self.callPackage (./pkgs/indexed-traversable-instances.nix) { };
 
-  infer-license = prev.callPackage (./pkgs/infer-license.nix) { };
+  infer-license = self.callPackage (./pkgs/infer-license.nix) { };
 
-  insert-ordered-containers = prev.callPackage (./pkgs/insert-ordered-containers.nix) { };
+  insert-ordered-containers = self.callPackage (./pkgs/insert-ordered-containers.nix) { };
 
-  inspection-testing = prev.callPackage (./pkgs/inspection-testing.nix) { };
+  inspection-testing = self.callPackage (./pkgs/inspection-testing.nix) { };
 
-  integer-logarithms = prev.callPackage (./pkgs/integer-logarithms.nix) { };
+  integer-logarithms = self.callPackage (./pkgs/integer-logarithms.nix) { };
 
-  invariant = prev.callPackage (./pkgs/invariant.nix) { };
+  invariant = self.callPackage (./pkgs/invariant.nix) { };
 
-  iproute = prev.callPackage (./pkgs/iproute.nix) { };
+  iproute = self.callPackage (./pkgs/iproute.nix) { };
 
-  ipynb = prev.callPackage (./pkgs/ipynb.nix) { };
+  ipynb = self.callPackage (./pkgs/ipynb.nix) { };
 
-  kan-extensions = prev.callPackage (./pkgs/kan-extensions.nix) { };
+  kan-extensions = self.callPackage (./pkgs/kan-extensions.nix) { };
 
-  keys = prev.callPackage (./pkgs/keys.nix) { };
+  keys = self.callPackage (./pkgs/keys.nix) { };
 
-  kvstore-effectful = prev.callPackage (./pkgs/kvstore-effectful.nix) { };
+  kvstore-effectful = self.callPackage (./pkgs/kvstore-effectful.nix) { };
 
-  kvstore-effectful-cache = prev.callPackage (./pkgs/kvstore-effectful-cache.nix) { };
+  kvstore-effectful-cache = self.callPackage (./pkgs/kvstore-effectful-cache.nix) { };
 
-  kvstore-effectful-spec = prev.callPackage (./pkgs/kvstore-effectful-spec.nix) { };
+  kvstore-effectful-spec = self.callPackage (./pkgs/kvstore-effectful-spec.nix) { };
 
-  kvstore-effectful-statemap = prev.callPackage (./pkgs/kvstore-effectful-statemap.nix) { };
+  kvstore-effectful-statemap = self.callPackage (./pkgs/kvstore-effectful-statemap.nix) { };
 
-  language-nix = prev.callPackage (./pkgs/language-nix.nix) { };
+  language-nix = self.callPackage (./pkgs/language-nix.nix) { };
 
-  lens = prev.callPackage (./pkgs/lens.nix) { };
+  lens = self.callPackage (./pkgs/lens.nix) { };
 
-  lens-aeson = prev.callPackage (./pkgs/lens-aeson.nix) { };
+  lens-aeson = self.callPackage (./pkgs/lens-aeson.nix) { };
 
-  lens-family-th = prev.callPackage (./pkgs/lens-family-th.nix) { };
+  lens-family-th = self.callPackage (./pkgs/lens-family-th.nix) { };
 
-  libsodium = prev.callPackage (./pkgs/libsodium.nix) { };
+  libsodium = self.callPackage (./pkgs/libsodium.nix) { };
 
-  libyaml = prev.callPackage (./pkgs/libyaml.nix) { };
+  libyaml = self.callPackage (./pkgs/libyaml.nix) { };
 
-  lifted-async = prev.callPackage (./pkgs/lifted-async.nix) { };
+  lifted-async = self.callPackage (./pkgs/lifted-async.nix) { };
 
-  lifted-base = prev.callPackage (./pkgs/lifted-base.nix) { };
+  lifted-base = self.callPackage (./pkgs/lifted-base.nix) { };
 
-  linear = prev.callPackage (./pkgs/linear.nix) { };
+  linear = self.callPackage (./pkgs/linear.nix) { };
 
-  log-base = prev.callPackage (./pkgs/log-base.nix) { };
+  log-base = self.callPackage (./pkgs/log-base.nix) { };
 
-  log-effectful = prev.callPackage (./pkgs/log-effectful.nix) { };
+  log-effectful = self.callPackage (./pkgs/log-effectful.nix) { };
 
-  lpeg = prev.callPackage (./pkgs/lpeg.nix) { };
+  lpeg = self.callPackage (./pkgs/lpeg.nix) { };
 
-  lsp = prev.callPackage (./pkgs/lsp.nix) { };
+  lsp = self.callPackage (./pkgs/lsp.nix) { };
 
-  lsp-types = prev.callPackage (./pkgs/lsp-types.nix) { };
+  lsp-types = self.callPackage (./pkgs/lsp-types.nix) { };
 
-  lua = prev.callPackage (./pkgs/lua.nix) { };
+  lua = self.callPackage (./pkgs/lua.nix) { };
 
-  lua-arbitrary = prev.callPackage (./pkgs/lua-arbitrary.nix) { };
+  lua-arbitrary = self.callPackage (./pkgs/lua-arbitrary.nix) { };
 
-  lucid = prev.callPackage (./pkgs/lucid.nix) { };
+  lucid = self.callPackage (./pkgs/lucid.nix) { };
 
-  lucid-alpine = prev.callPackage (./pkgs/lucid-alpine.nix) { };
+  lucid-alpine = self.callPackage (./pkgs/lucid-alpine.nix) { };
 
-  lucid-aria = prev.callPackage (./pkgs/lucid-aria.nix) { };
+  lucid-aria = self.callPackage (./pkgs/lucid-aria.nix) { };
 
-  lucid-svg = prev.callPackage (./pkgs/lucid-svg.nix) { };
+  lucid-svg = self.callPackage (./pkgs/lucid-svg.nix) { };
 
-  lukko = prev.callPackage (./pkgs/lukko.nix) { };
+  lukko = self.callPackage (./pkgs/lukko.nix) { };
 
-  markdown-unlit = prev.callPackage (./pkgs/markdown-unlit.nix) { };
+  markdown-unlit = self.callPackage (./pkgs/markdown-unlit.nix) { };
 
-  math-functions = prev.callPackage (./pkgs/math-functions.nix) { };
+  math-functions = self.callPackage (./pkgs/math-functions.nix) { };
 
-  megaparsec = prev.callPackage (./pkgs/megaparsec.nix) { };
+  megaparsec = self.callPackage (./pkgs/megaparsec.nix) { };
 
-  memory = prev.callPackage (./pkgs/memory.nix) { };
+  memory = self.callPackage (./pkgs/memory.nix) { };
 
-  microlens-aeson = prev.callPackage (./pkgs/microlens-aeson.nix) { };
+  microlens-aeson = self.callPackage (./pkgs/microlens-aeson.nix) { };
 
-  microstache = prev.callPackage (./pkgs/microstache.nix) { };
+  microstache = self.callPackage (./pkgs/microstache.nix) { };
 
-  mockery = prev.callPackage (./pkgs/mockery.nix) { };
+  mockery = self.callPackage (./pkgs/mockery.nix) { };
 
-  mod = prev.callPackage (./pkgs/mod.nix) { };
+  mod = self.callPackage (./pkgs/mod.nix) { };
 
-  monad-control = prev.callPackage (./pkgs/monad-control.nix) { };
+  monad-control = self.callPackage (./pkgs/monad-control.nix) { };
 
-  monad-logger = prev.callPackage (./pkgs/monad-logger.nix) { };
+  monad-logger = self.callPackage (./pkgs/monad-logger.nix) { };
 
-  monad-par = prev.callPackage (./pkgs/monad-par.nix) { };
+  monad-par = self.callPackage (./pkgs/monad-par.nix) { };
 
-  monad-par-extras = prev.callPackage (./pkgs/monad-par-extras.nix) { };
+  monad-par-extras = self.callPackage (./pkgs/monad-par-extras.nix) { };
 
-  monad-time = prev.callPackage (./pkgs/monad-time.nix) { };
+  monad-time = self.callPackage (./pkgs/monad-time.nix) { };
 
-  mono-traversable = prev.callPackage (./pkgs/mono-traversable.nix) { };
+  mono-traversable = self.callPackage (./pkgs/mono-traversable.nix) { };
 
-  monoid-subclasses = prev.callPackage (./pkgs/monoid-subclasses.nix) { };
+  monoid-subclasses = self.callPackage (./pkgs/monoid-subclasses.nix) { };
 
-  mwc-random = prev.callPackage (./pkgs/mwc-random.nix) { };
+  mwc-random = self.callPackage (./pkgs/mwc-random.nix) { };
 
-  net-mqtt = prev.callPackage (./pkgs/net-mqtt.nix) { };
+  net-mqtt = self.callPackage (./pkgs/net-mqtt.nix) { };
 
-  network = prev.callPackage (./pkgs/network.nix) { };
+  network = self.callPackage (./pkgs/network.nix) { };
 
-  network-byte-order = prev.callPackage (./pkgs/network-byte-order.nix) { };
+  network-byte-order = self.callPackage (./pkgs/network-byte-order.nix) { };
 
-  network-conduit-tls = prev.callPackage (./pkgs/network-conduit-tls.nix) { };
+  network-conduit-tls = self.callPackage (./pkgs/network-conduit-tls.nix) { };
 
-  network-uri = prev.callPackage (./pkgs/network-uri.nix) { };
+  network-uri = self.callPackage (./pkgs/network-uri.nix) { };
 
-  newtype-generics = prev.callPackage (./pkgs/newtype-generics.nix) { };
+  newtype-generics = self.callPackage (./pkgs/newtype-generics.nix) { };
 
-  nothunks = prev.callPackage (./pkgs/nothunks.nix) { };
+  nothunks = self.callPackage (./pkgs/nothunks.nix) { };
 
-  odd-jobs = prev.callPackage (./pkgs/odd-jobs.nix) { };
+  odd-jobs = self.callPackage (./pkgs/odd-jobs.nix) { };
 
-  optics = prev.callPackage (./pkgs/optics.nix) { };
+  optics = self.callPackage (./pkgs/optics.nix) { };
 
-  optics-core = prev.callPackage (./pkgs/optics-core.nix) { };
+  optics-core = self.callPackage (./pkgs/optics-core.nix) { };
 
-  optics-extra = prev.callPackage (./pkgs/optics-extra.nix) { };
+  optics-extra = self.callPackage (./pkgs/optics-extra.nix) { };
 
-  optics-th = prev.callPackage (./pkgs/optics-th.nix) { };
+  optics-th = self.callPackage (./pkgs/optics-th.nix) { };
 
-  optparse-applicative = prev.callPackage (./pkgs/optparse-applicative.nix) { };
+  optparse-applicative = self.callPackage (./pkgs/optparse-applicative.nix) { };
 
-  pandoc = prev.callPackage (./pkgs/pandoc.nix) { };
+  pandoc = self.callPackage (./pkgs/pandoc.nix) { };
 
-  pandoc-lua-marshal = prev.callPackage (./pkgs/pandoc-lua-marshal.nix) { };
+  pandoc-lua-marshal = self.callPackage (./pkgs/pandoc-lua-marshal.nix) { };
 
-  pandoc-types = prev.callPackage (./pkgs/pandoc-types.nix) { };
+  pandoc-types = self.callPackage (./pkgs/pandoc-types.nix) { };
 
-  parallel = prev.callPackage (./pkgs/parallel.nix) { };
+  parallel = self.callPackage (./pkgs/parallel.nix) { };
 
-  parsers = prev.callPackage (./pkgs/parsers.nix) { };
+  parsers = self.callPackage (./pkgs/parsers.nix) { };
 
-  password = prev.callPackage (./pkgs/password.nix) { };
+  password = self.callPackage (./pkgs/password.nix) { };
 
-  password-types = prev.callPackage (./pkgs/password-types.nix) { };
+  password-types = self.callPackage (./pkgs/password-types.nix) { };
 
-  path = prev.callPackage (./pkgs/path.nix) { };
+  path = self.callPackage (./pkgs/path.nix) { };
 
-  path-dhall-instance = prev.callPackage (./pkgs/path-dhall-instance.nix) { };
+  path-dhall-instance = self.callPackage (./pkgs/path-dhall-instance.nix) { };
 
-  path-io = prev.callPackage (./pkgs/path-io.nix) { };
+  path-io = self.callPackage (./pkgs/path-io.nix) { };
 
-  pcg-random = prev.callPackage (./pkgs/pcg-random.nix) { };
+  pcg-random = self.callPackage (./pkgs/pcg-random.nix) { };
 
-  pcre2 = prev.callPackage (./pkgs/pcre2.nix) { };
+  pcre2 = self.callPackage (./pkgs/pcre2.nix) { };
 
-  pem = prev.callPackage (./pkgs/pem.nix) { };
+  pem = self.callPackage (./pkgs/pem.nix) { };
 
-  persistent = prev.callPackage (./pkgs/persistent.nix) { };
+  persistent = self.callPackage (./pkgs/persistent.nix) { };
 
-  pg-entity = prev.callPackage (./pkgs/pg-entity.nix) { };
+  pg-entity = self.callPackage (./pkgs/pg-entity.nix) { };
 
-  pg-transact = prev.callPackage (./pkgs/pg-transact.nix) { };
+  pg-transact = self.callPackage (./pkgs/pg-transact.nix) { };
 
-  pg-transact-effectful = prev.callPackage (./pkgs/pg-transact-effectful.nix) { };
+  pg-transact-effectful = self.callPackage (./pkgs/pg-transact-effectful.nix) { };
 
-  pointed = prev.callPackage (./pkgs/pointed.nix) { };
+  pointed = self.callPackage (./pkgs/pointed.nix) { };
 
-  polysemy = prev.callPackage (./pkgs/polysemy.nix) { };
+  polysemy = self.callPackage (./pkgs/polysemy.nix) { };
 
-  polysemy-extra = prev.callPackage (./pkgs/polysemy-extra.nix) { };
+  polysemy-extra = self.callPackage (./pkgs/polysemy-extra.nix) { };
 
-  polysemy-kvstore = prev.callPackage (./pkgs/polysemy-kvstore.nix) { };
+  polysemy-kvstore = self.callPackage (./pkgs/polysemy-kvstore.nix) { };
 
-  polysemy-methodology = prev.callPackage (./pkgs/polysemy-methodology.nix) { };
+  polysemy-methodology = self.callPackage (./pkgs/polysemy-methodology.nix) { };
 
-  polysemy-path = prev.callPackage (./pkgs/polysemy-path.nix) { };
+  polysemy-path = self.callPackage (./pkgs/polysemy-path.nix) { };
 
-  polysemy-plugin = prev.callPackage (./pkgs/polysemy-plugin.nix) { };
+  polysemy-plugin = self.callPackage (./pkgs/polysemy-plugin.nix) { };
 
-  polysemy-several = prev.callPackage (./pkgs/polysemy-several.nix) { };
+  polysemy-several = self.callPackage (./pkgs/polysemy-several.nix) { };
 
-  polysemy-time = prev.callPackage (./pkgs/polysemy-time.nix) { };
+  polysemy-time = self.callPackage (./pkgs/polysemy-time.nix) { };
 
-  polysemy-vinyl = prev.callPackage (./pkgs/polysemy-vinyl.nix) { };
+  polysemy-vinyl = self.callPackage (./pkgs/polysemy-vinyl.nix) { };
 
-  polysemy-zoo = prev.callPackage (./pkgs/polysemy-zoo.nix) { };
+  polysemy-zoo = self.callPackage (./pkgs/polysemy-zoo.nix) { };
 
-  postgresql-libpq = prev.callPackage (./pkgs/postgresql-libpq.nix) { };
+  postgresql-libpq = self.callPackage (./pkgs/postgresql-libpq.nix) { };
 
-  postgresql-migration = prev.callPackage (./pkgs/postgresql-migration.nix) { };
+  postgresql-migration = self.callPackage (./pkgs/postgresql-migration.nix) { };
 
-  postgresql-simple = prev.callPackage (./pkgs/postgresql-simple.nix) { };
+  postgresql-simple = self.callPackage (./pkgs/postgresql-simple.nix) { };
 
-  postgresql-simple-migration = prev.callPackage (./pkgs/postgresql-simple-migration.nix) { };
+  postgresql-simple-migration = self.callPackage (./pkgs/postgresql-simple-migration.nix) { };
 
-  pretty-show = prev.callPackage (./pkgs/pretty-show.nix) { };
+  pretty-show = self.callPackage (./pkgs/pretty-show.nix) { };
 
-  pretty-simple = prev.callPackage (./pkgs/pretty-simple.nix) { };
+  pretty-simple = self.callPackage (./pkgs/pretty-simple.nix) { };
 
-  prettyprinter-ansi-terminal = prev.callPackage (./pkgs/prettyprinter-ansi-terminal.nix) { };
+  prettyprinter-ansi-terminal = self.callPackage (./pkgs/prettyprinter-ansi-terminal.nix) { };
 
-  primitive = prev.callPackage (./pkgs/primitive.nix) { };
+  primitive = self.callPackage (./pkgs/primitive.nix) { };
 
-  primitive-addr = prev.callPackage (./pkgs/primitive-addr.nix) { };
+  primitive-addr = self.callPackage (./pkgs/primitive-addr.nix) { };
 
-  profunctors = prev.callPackage (./pkgs/profunctors.nix) { };
+  profunctors = self.callPackage (./pkgs/profunctors.nix) { };
 
-  prometheus-client = prev.callPackage (./pkgs/prometheus-client.nix) { };
+  prometheus-client = self.callPackage (./pkgs/prometheus-client.nix) { };
 
-  prometheus-proc = prev.callPackage (./pkgs/prometheus-proc.nix) { };
+  prometheus-proc = self.callPackage (./pkgs/prometheus-proc.nix) { };
 
-  proteaaudio-sdl = prev.callPackage (./pkgs/proteaaudio-sdl.nix) { };
+  proteaaudio-sdl = self.callPackage (./pkgs/proteaaudio-sdl.nix) { };
 
-  psqueues = prev.callPackage (./pkgs/psqueues.nix) { };
+  psqueues = self.callPackage (./pkgs/psqueues.nix) { };
 
-  quickcheck-classes = prev.callPackage (./pkgs/quickcheck-classes.nix) { };
+  quickcheck-classes = self.callPackage (./pkgs/quickcheck-classes.nix) { };
 
-  quickcheck-dynamic = prev.callPackage (./pkgs/quickcheck-dynamic.nix) { };
+  quickcheck-dynamic = self.callPackage (./pkgs/quickcheck-dynamic.nix) { };
 
-  quickcheck-instances = prev.callPackage (./pkgs/quickcheck-instances.nix) { };
+  quickcheck-instances = self.callPackage (./pkgs/quickcheck-instances.nix) { };
 
-  random-shuffle = prev.callPackage (./pkgs/random-shuffle.nix) { };
+  random-shuffle = self.callPackage (./pkgs/random-shuffle.nix) { };
 
-  rebase = prev.callPackage (./pkgs/rebase.nix) { };
+  rebase = self.callPackage (./pkgs/rebase.nix) { };
 
-  reducers = prev.callPackage (./pkgs/reducers.nix) { };
+  reducers = self.callPackage (./pkgs/reducers.nix) { };
 
-  refined = prev.callPackage (./pkgs/refined.nix) { };
+  refined = self.callPackage (./pkgs/refined.nix) { };
 
-  reflection = prev.callPackage (./pkgs/reflection.nix) { };
+  reflection = self.callPackage (./pkgs/reflection.nix) { };
 
-  regex-applicative = prev.callPackage (./pkgs/regex-applicative.nix) { };
+  regex-applicative = self.callPackage (./pkgs/regex-applicative.nix) { };
 
-  regex-tdfa = prev.callPackage (./pkgs/regex-tdfa.nix) { };
+  regex-tdfa = self.callPackage (./pkgs/regex-tdfa.nix) { };
 
-  relude = prev.callPackage (./pkgs/relude.nix) { };
+  relude = self.callPackage (./pkgs/relude.nix) { };
 
-  rere = prev.callPackage (./pkgs/rere.nix) { };
+  rere = self.callPackage (./pkgs/rere.nix) { };
 
-  rerebase = prev.callPackage (./pkgs/rerebase.nix) { };
+  rerebase = self.callPackage (./pkgs/rerebase.nix) { };
 
-  resource-pool = prev.callPackage (./pkgs/resource-pool.nix) { };
+  resource-pool = self.callPackage (./pkgs/resource-pool.nix) { };
 
-  resourcet = prev.callPackage (./pkgs/resourcet.nix) { };
+  resourcet = self.callPackage (./pkgs/resourcet.nix) { };
 
-  retry = prev.callPackage (./pkgs/retry.nix) { };
+  retry = self.callPackage (./pkgs/retry.nix) { };
 
-  rope-utf16-splay = prev.callPackage (./pkgs/rope-utf16-splay.nix) { };
+  rope-utf16-splay = self.callPackage (./pkgs/rope-utf16-splay.nix) { };
 
-  safe-coloured-text = prev.callPackage (./pkgs/safe-coloured-text.nix) { };
+  safe-coloured-text = self.callPackage (./pkgs/safe-coloured-text.nix) { };
 
-  safe-coloured-text-terminfo = prev.callPackage (./pkgs/safe-coloured-text-terminfo.nix) { };
+  safe-coloured-text-terminfo = self.callPackage (./pkgs/safe-coloured-text-terminfo.nix) { };
 
-  safe-exceptions = prev.callPackage (./pkgs/safe-exceptions.nix) { };
+  safe-exceptions = self.callPackage (./pkgs/safe-exceptions.nix) { };
 
-  saltine = prev.callPackage (./pkgs/saltine.nix) { };
+  saltine = self.callPackage (./pkgs/saltine.nix) { };
 
-  scientific = prev.callPackage (./pkgs/scientific.nix) { };
+  scientific = self.callPackage (./pkgs/scientific.nix) { };
 
-  scotty = prev.callPackage (./pkgs/scotty.nix) { };
+  scotty = self.callPackage (./pkgs/scotty.nix) { };
 
-  sdl2 = prev.callPackage (./pkgs/sdl2.nix) { };
+  sdl2 = self.callPackage (./pkgs/sdl2.nix) { };
 
-  sdl2-gfx = prev.callPackage (./pkgs/sdl2-gfx.nix) { };
+  sdl2-gfx = self.callPackage (./pkgs/sdl2-gfx.nix) { };
 
-  sdl2-image = prev.callPackage (./pkgs/sdl2-image.nix) { };
+  sdl2-image = self.callPackage (./pkgs/sdl2-image.nix) { };
 
-  sdl2-mixer = prev.callPackage (./pkgs/sdl2-mixer.nix) { };
+  sdl2-mixer = self.callPackage (./pkgs/sdl2-mixer.nix) { };
 
-  sdl2-ttf = prev.callPackage (./pkgs/sdl2-ttf.nix) { };
+  sdl2-ttf = self.callPackage (./pkgs/sdl2-ttf.nix) { };
 
-  semialign = prev.callPackage (./pkgs/semialign.nix) { };
+  semialign = self.callPackage (./pkgs/semialign.nix) { };
 
-  semigroupoids = prev.callPackage (./pkgs/semigroupoids.nix) { };
+  semigroupoids = self.callPackage (./pkgs/semigroupoids.nix) { };
 
-  semigroups = prev.callPackage (./pkgs/semigroups.nix) { };
+  semigroups = self.callPackage (./pkgs/semigroups.nix) { };
 
-  semirings = prev.callPackage (./pkgs/semirings.nix) { };
+  semirings = self.callPackage (./pkgs/semirings.nix) { };
 
-  serialise = prev.callPackage (./pkgs/serialise.nix) { };
+  serialise = self.callPackage (./pkgs/serialise.nix) { };
 
-  servant = prev.callPackage (./pkgs/servant.nix) { };
+  servant = self.callPackage (./pkgs/servant.nix) { };
 
-  servant-blaze = prev.callPackage (./pkgs/servant-blaze.nix) { };
+  servant-blaze = self.callPackage (./pkgs/servant-blaze.nix) { };
 
-  servant-client = prev.callPackage (./pkgs/servant-client.nix) { };
+  servant-client = self.callPackage (./pkgs/servant-client.nix) { };
 
-  servant-client-core = prev.callPackage (./pkgs/servant-client-core.nix) { };
+  servant-client-core = self.callPackage (./pkgs/servant-client-core.nix) { };
 
-  servant-docs = prev.callPackage (./pkgs/servant-docs.nix) { };
+  servant-docs = self.callPackage (./pkgs/servant-docs.nix) { };
 
-  servant-effectful = prev.callPackage (./pkgs/servant-effectful.nix) { };
+  servant-effectful = self.callPackage (./pkgs/servant-effectful.nix) { };
 
-  servant-foreign = prev.callPackage (./pkgs/servant-foreign.nix) { };
+  servant-foreign = self.callPackage (./pkgs/servant-foreign.nix) { };
 
-  servant-lucid = prev.callPackage (./pkgs/servant-lucid.nix) { };
+  servant-lucid = self.callPackage (./pkgs/servant-lucid.nix) { };
 
-  servant-multipart = prev.callPackage (./pkgs/servant-multipart.nix) { };
+  servant-multipart = self.callPackage (./pkgs/servant-multipart.nix) { };
 
-  servant-multipart-api = prev.callPackage (./pkgs/servant-multipart-api.nix) { };
+  servant-multipart-api = self.callPackage (./pkgs/servant-multipart-api.nix) { };
 
-  servant-polysemy = prev.callPackage (./pkgs/servant-polysemy.nix) { };
+  servant-polysemy = self.callPackage (./pkgs/servant-polysemy.nix) { };
 
-  servant-server = prev.callPackage (./pkgs/servant-server.nix) { };
+  servant-server = self.callPackage (./pkgs/servant-server.nix) { };
 
-  servant-static-th = prev.callPackage (./pkgs/servant-static-th.nix) { };
+  servant-static-th = self.callPackage (./pkgs/servant-static-th.nix) { };
 
-  servant-swagger = prev.callPackage (./pkgs/servant-swagger.nix) { };
+  servant-swagger = self.callPackage (./pkgs/servant-swagger.nix) { };
 
-  servant-swagger-ui = prev.callPackage (./pkgs/servant-swagger-ui.nix) { };
+  servant-swagger-ui = self.callPackage (./pkgs/servant-swagger-ui.nix) { };
 
-  servant-swagger-ui-core = prev.callPackage (./pkgs/servant-swagger-ui-core.nix) { };
+  servant-swagger-ui-core = self.callPackage (./pkgs/servant-swagger-ui-core.nix) { };
 
-  shake = prev.callPackage (./pkgs/shake.nix) { };
+  shake = self.callPackage (./pkgs/shake.nix) { };
 
-  shakespeare = prev.callPackage (./pkgs/shakespeare.nix) { };
+  shakespeare = self.callPackage (./pkgs/shakespeare.nix) { };
 
-  shelly = prev.callPackage (./pkgs/shelly.nix) { };
+  shelly = self.callPackage (./pkgs/shelly.nix) { };
 
-  simple-sendfile = prev.callPackage (./pkgs/simple-sendfile.nix) { };
+  simple-sendfile = self.callPackage (./pkgs/simple-sendfile.nix) { };
 
-  singleton-bool = prev.callPackage (./pkgs/singleton-bool.nix) { };
+  singleton-bool = self.callPackage (./pkgs/singleton-bool.nix) { };
 
-  singletons = prev.callPackage (./pkgs/singletons.nix) { };
+  singletons = self.callPackage (./pkgs/singletons.nix) { };
 
-  skylighting = prev.callPackage (./pkgs/skylighting.nix) { };
+  skylighting = self.callPackage (./pkgs/skylighting.nix) { };
 
-  skylighting-core = prev.callPackage (./pkgs/skylighting-core.nix) { };
+  skylighting-core = self.callPackage (./pkgs/skylighting-core.nix) { };
 
-  skylighting-format-ansi = prev.callPackage (./pkgs/skylighting-format-ansi.nix) { };
+  skylighting-format-ansi = self.callPackage (./pkgs/skylighting-format-ansi.nix) { };
 
-  skylighting-format-blaze-html = prev.callPackage (./pkgs/skylighting-format-blaze-html.nix) { };
+  skylighting-format-blaze-html = self.callPackage (./pkgs/skylighting-format-blaze-html.nix) { };
 
-  skylighting-format-latex = prev.callPackage (./pkgs/skylighting-format-latex.nix) { };
+  skylighting-format-latex = self.callPackage (./pkgs/skylighting-format-latex.nix) { };
 
-  slugify = prev.callPackage (./pkgs/slugify.nix) { };
+  slugify = self.callPackage (./pkgs/slugify.nix) { };
 
-  socks = prev.callPackage (./pkgs/socks.nix) { };
+  socks = self.callPackage (./pkgs/socks.nix) { };
 
-  some = prev.callPackage (./pkgs/some.nix) { };
+  some = self.callPackage (./pkgs/some.nix) { };
 
-  sop-core = prev.callPackage (./pkgs/sop-core.nix) { };
+  sop-core = self.callPackage (./pkgs/sop-core.nix) { };
 
-  souffle-haskell = prev.callPackage (./pkgs/souffle-haskell.nix) { };
+  souffle-haskell = self.callPackage (./pkgs/souffle-haskell.nix) { };
 
-  split = prev.callPackage (./pkgs/split.nix) { };
+  split = self.callPackage (./pkgs/split.nix) { };
 
-  sqlite-simple = prev.callPackage (./pkgs/sqlite-simple.nix) { };
+  sqlite-simple = self.callPackage (./pkgs/sqlite-simple.nix) { };
 
-  statistics = prev.callPackage (./pkgs/statistics.nix) { };
+  statistics = self.callPackage (./pkgs/statistics.nix) { };
 
-  streaming-commons = prev.callPackage (./pkgs/streaming-commons.nix) { };
+  streaming-commons = self.callPackage (./pkgs/streaming-commons.nix) { };
 
-  strict = prev.callPackage (./pkgs/strict.nix) { };
+  strict = self.callPackage (./pkgs/strict.nix) { };
 
-  string-interpolate = prev.callPackage (./pkgs/string-interpolate.nix) { };
+  string-interpolate = self.callPackage (./pkgs/string-interpolate.nix) { };
 
-  string-qq = prev.callPackage (./pkgs/string-qq.nix) { };
+  string-qq = self.callPackage (./pkgs/string-qq.nix) { };
 
-  swagger2 = prev.callPackage (./pkgs/swagger2.nix) { };
+  swagger2 = self.callPackage (./pkgs/swagger2.nix) { };
 
-  syb = prev.callPackage (./pkgs/syb.nix) { };
+  syb = self.callPackage (./pkgs/syb.nix) { };
 
-  sydtest = prev.callPackage (./pkgs/sydtest.nix) { };
+  sydtest = self.callPackage (./pkgs/sydtest.nix) { };
 
-  sydtest-discover = prev.callPackage (./pkgs/sydtest-discover.nix) { };
+  sydtest-discover = self.callPackage (./pkgs/sydtest-discover.nix) { };
 
-  tagged = prev.callPackage (./pkgs/tagged.nix) { };
+  tagged = self.callPackage (./pkgs/tagged.nix) { };
 
-  tasty = prev.callPackage (./pkgs/tasty.nix) { };
+  tasty = self.callPackage (./pkgs/tasty.nix) { };
 
-  tasty-discover = prev.callPackage (./pkgs/tasty-discover.nix) { };
+  tasty-discover = self.callPackage (./pkgs/tasty-discover.nix) { };
 
-  tasty-expected-failure = prev.callPackage (./pkgs/tasty-expected-failure.nix) { };
+  tasty-expected-failure = self.callPackage (./pkgs/tasty-expected-failure.nix) { };
 
-  tasty-golden = prev.callPackage (./pkgs/tasty-golden.nix) { };
+  tasty-golden = self.callPackage (./pkgs/tasty-golden.nix) { };
 
-  tasty-hedgehog = prev.callPackage (./pkgs/tasty-hedgehog.nix) { };
+  tasty-hedgehog = self.callPackage (./pkgs/tasty-hedgehog.nix) { };
 
-  tasty-hslua = prev.callPackage (./pkgs/tasty-hslua.nix) { };
+  tasty-hslua = self.callPackage (./pkgs/tasty-hslua.nix) { };
 
-  tasty-hunit = prev.callPackage (./pkgs/tasty-hunit.nix) { };
+  tasty-hunit = self.callPackage (./pkgs/tasty-hunit.nix) { };
 
-  tasty-lua = prev.callPackage (./pkgs/tasty-lua.nix) { };
+  tasty-lua = self.callPackage (./pkgs/tasty-lua.nix) { };
 
-  tasty-quickcheck = prev.callPackage (./pkgs/tasty-quickcheck.nix) { };
+  tasty-quickcheck = self.callPackage (./pkgs/tasty-quickcheck.nix) { };
 
-  tasty-smallcheck = prev.callPackage (./pkgs/tasty-smallcheck.nix) { };
+  tasty-smallcheck = self.callPackage (./pkgs/tasty-smallcheck.nix) { };
 
-  tasty-wai = prev.callPackage (./pkgs/tasty-wai.nix) { };
+  tasty-wai = self.callPackage (./pkgs/tasty-wai.nix) { };
 
-  test-framework = prev.callPackage (./pkgs/test-framework.nix) { };
+  test-framework = self.callPackage (./pkgs/test-framework.nix) { };
 
-  test-framework-hunit = prev.callPackage (./pkgs/test-framework-hunit.nix) { };
+  test-framework-hunit = self.callPackage (./pkgs/test-framework-hunit.nix) { };
 
-  test-framework-quickcheck2 = prev.callPackage (./pkgs/test-framework-quickcheck2.nix) { };
+  test-framework-quickcheck2 = self.callPackage (./pkgs/test-framework-quickcheck2.nix) { };
 
-  texmath = prev.callPackage (./pkgs/texmath.nix) { };
+  texmath = self.callPackage (./pkgs/texmath.nix) { };
 
-  text-display = prev.callPackage (./pkgs/text-display.nix) { };
+  text-display = self.callPackage (./pkgs/text-display.nix) { };
 
-  text-manipulate = prev.callPackage (./pkgs/text-manipulate.nix) { };
+  text-manipulate = self.callPackage (./pkgs/text-manipulate.nix) { };
 
-  text-metrics = prev.callPackage (./pkgs/text-metrics.nix) { };
+  text-metrics = self.callPackage (./pkgs/text-metrics.nix) { };
 
-  text-rope = prev.callPackage (./pkgs/text-rope.nix) { };
+  text-rope = self.callPackage (./pkgs/text-rope.nix) { };
 
-  text-short = prev.callPackage (./pkgs/text-short.nix) { };
+  text-short = self.callPackage (./pkgs/text-short.nix) { };
 
-  text-zipper = prev.callPackage (./pkgs/text-zipper.nix) { };
+  text-zipper = self.callPackage (./pkgs/text-zipper.nix) { };
 
-  tf-random = prev.callPackage (./pkgs/tf-random.nix) { };
+  tf-random = self.callPackage (./pkgs/tf-random.nix) { };
 
-  th-env = prev.callPackage (./pkgs/th-env.nix) { };
+  th-env = self.callPackage (./pkgs/th-env.nix) { };
 
-  th-expand-syns = prev.callPackage (./pkgs/th-expand-syns.nix) { };
+  th-expand-syns = self.callPackage (./pkgs/th-expand-syns.nix) { };
 
-  th-extras = prev.callPackage (./pkgs/th-extras.nix) { };
+  th-extras = self.callPackage (./pkgs/th-extras.nix) { };
 
-  th-lift-instances = prev.callPackage (./pkgs/th-lift-instances.nix) { };
+  th-lift-instances = self.callPackage (./pkgs/th-lift-instances.nix) { };
 
-  th-orphans = prev.callPackage (./pkgs/th-orphans.nix) { };
+  th-orphans = self.callPackage (./pkgs/th-orphans.nix) { };
 
-  th-reify-many = prev.callPackage (./pkgs/th-reify-many.nix) { };
+  th-reify-many = self.callPackage (./pkgs/th-reify-many.nix) { };
 
-  these = prev.callPackage (./pkgs/these.nix) { };
+  these = self.callPackage (./pkgs/these.nix) { };
 
-  these-skinny = prev.callPackage (./pkgs/these-skinny.nix) { };
+  these-skinny = self.callPackage (./pkgs/these-skinny.nix) { };
 
-  tidal = prev.callPackage (./pkgs/tidal.nix) { };
+  tidal = self.callPackage (./pkgs/tidal.nix) { };
 
-  time-compat = prev.callPackage (./pkgs/time-compat.nix) { };
+  time-compat = self.callPackage (./pkgs/time-compat.nix) { };
 
-  time-effectful = prev.callPackage (./pkgs/time-effectful.nix) { };
+  time-effectful = self.callPackage (./pkgs/time-effectful.nix) { };
 
-  tls = prev.callPackage (./pkgs/tls.nix) { };
+  tls = self.callPackage (./pkgs/tls.nix) { };
 
-  tls-session-manager = prev.callPackage (./pkgs/tls-session-manager.nix) { };
+  tls-session-manager = self.callPackage (./pkgs/tls-session-manager.nix) { };
 
-  tree-diff = prev.callPackage (./pkgs/tree-diff.nix) { };
+  tree-diff = self.callPackage (./pkgs/tree-diff.nix) { };
 
-  trifecta = prev.callPackage (./pkgs/trifecta.nix) { };
+  trifecta = self.callPackage (./pkgs/trifecta.nix) { };
 
-  type-equality = prev.callPackage (./pkgs/type-equality.nix) { };
+  type-equality = self.callPackage (./pkgs/type-equality.nix) { };
 
-  type-errors = prev.callPackage (./pkgs/type-errors.nix) { };
+  type-errors = self.callPackage (./pkgs/type-errors.nix) { };
 
-  type-errors-pretty = prev.callPackage (./pkgs/type-errors-pretty.nix) { };
+  type-errors-pretty = self.callPackage (./pkgs/type-errors-pretty.nix) { };
 
-  typed-process = prev.callPackage (./pkgs/typed-process.nix) { };
+  typed-process = self.callPackage (./pkgs/typed-process.nix) { };
 
-  typerep-map = prev.callPackage (./pkgs/typerep-map.nix) { };
+  typerep-map = self.callPackage (./pkgs/typerep-map.nix) { };
 
-  unagi-chan = prev.callPackage (./pkgs/unagi-chan.nix) { };
+  unagi-chan = self.callPackage (./pkgs/unagi-chan.nix) { };
 
-  unicode-collation = prev.callPackage (./pkgs/unicode-collation.nix) { };
+  unicode-collation = self.callPackage (./pkgs/unicode-collation.nix) { };
 
-  unicode-data = prev.callPackage (./pkgs/unicode-data.nix) { };
+  unicode-data = self.callPackage (./pkgs/unicode-data.nix) { };
 
-  unicode-transforms = prev.callPackage (./pkgs/unicode-transforms.nix) { };
+  unicode-transforms = self.callPackage (./pkgs/unicode-transforms.nix) { };
 
-  uniplate = prev.callPackage (./pkgs/uniplate.nix) { };
+  uniplate = self.callPackage (./pkgs/uniplate.nix) { };
 
-  universe-base = prev.callPackage (./pkgs/universe-base.nix) { };
+  universe-base = self.callPackage (./pkgs/universe-base.nix) { };
 
-  unliftio = prev.callPackage (./pkgs/unliftio.nix) { };
+  unliftio = self.callPackage (./pkgs/unliftio.nix) { };
 
-  unliftio-core = prev.callPackage (./pkgs/unliftio-core.nix) { };
+  unliftio-core = self.callPackage (./pkgs/unliftio-core.nix) { };
 
-  unordered-containers = prev.callPackage (./pkgs/unordered-containers.nix) { };
+  unordered-containers = self.callPackage (./pkgs/unordered-containers.nix) { };
 
-  uri-encode = prev.callPackage (./pkgs/uri-encode.nix) { };
+  uri-encode = self.callPackage (./pkgs/uri-encode.nix) { };
 
-  uuid = prev.callPackage (./pkgs/uuid.nix) { };
+  uuid = self.callPackage (./pkgs/uuid.nix) { };
 
-  uuid-types = prev.callPackage (./pkgs/uuid-types.nix) { };
+  uuid-types = self.callPackage (./pkgs/uuid-types.nix) { };
 
-  validity = prev.callPackage (./pkgs/validity.nix) { };
+  validity = self.callPackage (./pkgs/validity.nix) { };
 
-  validity-aeson = prev.callPackage (./pkgs/validity-aeson.nix) { };
+  validity-aeson = self.callPackage (./pkgs/validity-aeson.nix) { };
 
-  validity-bytestring = prev.callPackage (./pkgs/validity-bytestring.nix) { };
+  validity-bytestring = self.callPackage (./pkgs/validity-bytestring.nix) { };
 
-  validity-case-insensitive = prev.callPackage (./pkgs/validity-case-insensitive.nix) { };
+  validity-case-insensitive = self.callPackage (./pkgs/validity-case-insensitive.nix) { };
 
-  validity-containers = prev.callPackage (./pkgs/validity-containers.nix) { };
+  validity-containers = self.callPackage (./pkgs/validity-containers.nix) { };
 
-  validity-path = prev.callPackage (./pkgs/validity-path.nix) { };
+  validity-path = self.callPackage (./pkgs/validity-path.nix) { };
 
-  validity-persistent = prev.callPackage (./pkgs/validity-persistent.nix) { };
+  validity-persistent = self.callPackage (./pkgs/validity-persistent.nix) { };
 
-  validity-primitive = prev.callPackage (./pkgs/validity-primitive.nix) { };
+  validity-primitive = self.callPackage (./pkgs/validity-primitive.nix) { };
 
-  validity-scientific = prev.callPackage (./pkgs/validity-scientific.nix) { };
+  validity-scientific = self.callPackage (./pkgs/validity-scientific.nix) { };
 
-  validity-text = prev.callPackage (./pkgs/validity-text.nix) { };
+  validity-text = self.callPackage (./pkgs/validity-text.nix) { };
 
-  validity-time = prev.callPackage (./pkgs/validity-time.nix) { };
+  validity-time = self.callPackage (./pkgs/validity-time.nix) { };
 
-  validity-unordered-containers = prev.callPackage (./pkgs/validity-unordered-containers.nix) { };
+  validity-unordered-containers = self.callPackage (./pkgs/validity-unordered-containers.nix) { };
 
-  validity-uuid = prev.callPackage (./pkgs/validity-uuid.nix) { };
+  validity-uuid = self.callPackage (./pkgs/validity-uuid.nix) { };
 
-  validity-vector = prev.callPackage (./pkgs/validity-vector.nix) { };
+  validity-vector = self.callPackage (./pkgs/validity-vector.nix) { };
 
-  vault = prev.callPackage (./pkgs/vault.nix) { };
+  vault = self.callPackage (./pkgs/vault.nix) { };
 
-  vec = prev.callPackage (./pkgs/vec.nix) { };
+  vec = self.callPackage (./pkgs/vec.nix) { };
 
-  vector = prev.callPackage (./pkgs/vector.nix) { };
+  vector = self.callPackage (./pkgs/vector.nix) { };
 
-  vector-algorithms = prev.callPackage (./pkgs/vector-algorithms.nix) { };
+  vector-algorithms = self.callPackage (./pkgs/vector-algorithms.nix) { };
 
-  vector-binary-instances = prev.callPackage (./pkgs/vector-binary-instances.nix) { };
+  vector-binary-instances = self.callPackage (./pkgs/vector-binary-instances.nix) { };
 
-  vector-instances = prev.callPackage (./pkgs/vector-instances.nix) { };
+  vector-instances = self.callPackage (./pkgs/vector-instances.nix) { };
 
-  vector-th-unbox = prev.callPackage (./pkgs/vector-th-unbox.nix) { };
+  vector-th-unbox = self.callPackage (./pkgs/vector-th-unbox.nix) { };
 
-  vinyl = prev.callPackage (./pkgs/vinyl.nix) { };
+  vinyl = self.callPackage (./pkgs/vinyl.nix) { };
 
-  void = prev.callPackage (./pkgs/void.nix) { };
+  void = self.callPackage (./pkgs/void.nix) { };
 
-  vty = prev.callPackage (./pkgs/vty.nix) { };
+  vty = self.callPackage (./pkgs/vty.nix) { };
 
-  wai = prev.callPackage (./pkgs/wai.nix) { };
+  wai = self.callPackage (./pkgs/wai.nix) { };
 
-  wai-app-static = prev.callPackage (./pkgs/wai-app-static.nix) { };
+  wai-app-static = self.callPackage (./pkgs/wai-app-static.nix) { };
 
-  wai-extra = prev.callPackage (./pkgs/wai-extra.nix) { };
+  wai-extra = self.callPackage (./pkgs/wai-extra.nix) { };
 
-  wai-logger = prev.callPackage (./pkgs/wai-logger.nix) { };
+  wai-logger = self.callPackage (./pkgs/wai-logger.nix) { };
 
-  wai-middleware-heartbeat = prev.callPackage (./pkgs/wai-middleware-heartbeat.nix) { };
+  wai-middleware-heartbeat = self.callPackage (./pkgs/wai-middleware-heartbeat.nix) { };
 
-  wai-middleware-static = prev.callPackage (./pkgs/wai-middleware-static.nix) { };
+  wai-middleware-static = self.callPackage (./pkgs/wai-middleware-static.nix) { };
 
-  warp = prev.callPackage (./pkgs/warp.nix) { };
+  warp = self.callPackage (./pkgs/warp.nix) { };
 
-  warp-tls = prev.callPackage (./pkgs/warp-tls.nix) { };
+  warp-tls = self.callPackage (./pkgs/warp-tls.nix) { };
 
-  websockets = prev.callPackage (./pkgs/websockets.nix) { };
+  websockets = self.callPackage (./pkgs/websockets.nix) { };
 
-  with-utf8 = prev.callPackage (./pkgs/with-utf8.nix) { };
+  with-utf8 = self.callPackage (./pkgs/with-utf8.nix) { };
 
-  witherable = prev.callPackage (./pkgs/witherable.nix) { };
+  witherable = self.callPackage (./pkgs/witherable.nix) { };
 
-  x509 = prev.callPackage (./pkgs/x509.nix) { };
+  x509 = self.callPackage (./pkgs/x509.nix) { };
 
-  x509-store = prev.callPackage (./pkgs/x509-store.nix) { };
+  x509-store = self.callPackage (./pkgs/x509-store.nix) { };
 
-  x509-system = prev.callPackage (./pkgs/x509-system.nix) { };
+  x509-system = self.callPackage (./pkgs/x509-system.nix) { };
 
-  x509-validation = prev.callPackage (./pkgs/x509-validation.nix) { };
+  x509-validation = self.callPackage (./pkgs/x509-validation.nix) { };
 
-  xml-conduit = prev.callPackage (./pkgs/xml-conduit.nix) { };
+  xml-conduit = self.callPackage (./pkgs/xml-conduit.nix) { };
 
-  yaml = prev.callPackage (./pkgs/yaml.nix) { };
+  yaml = self.callPackage (./pkgs/yaml.nix) { };
 
 }