overlay.nix

-{pkgs, lib, callPackage, ...}:
+/* This file is auto-generated by horizon-gen-nix. Do not edit. */
+{ pkgs, f ? (final: prev: n: v: v), ... }:
 
-self: with pkgs.haskell.lib; {
-  Cabal = self.callPackage (./pkgs/Cabal.nix) { };
+final: prev: with pkgs.haskell.lib; {
+  BNFC = f final prev "BNFC" (final.callPackage (./pkgs/BNFC.nix) { });
 
-  Cabal-QuickCheck = self.callPackage (./pkgs/Cabal-QuickCheck.nix) { };
+  Boolean = f final prev "Boolean" (final.callPackage (./pkgs/Boolean.nix) { });
 
-  Cabal-described = self.callPackage (./pkgs/Cabal-described.nix) { };
+  Decimal = f final prev "Decimal" (final.callPackage (./pkgs/Decimal.nix) { });
 
-  Cabal-syntax = self.callPackage (./pkgs/Cabal-syntax.nix) { };
+  Hclip = f final prev "Hclip" (final.callPackage (./pkgs/Hclip.nix) { });
 
-  Cabal-tree-diff = self.callPackage (./pkgs/Cabal-tree-diff.nix) { };
+  HsYAML = f final prev "HsYAML" (final.callPackage (./pkgs/HsYAML.nix) { });
 
-  ChasingBottoms = self.callPackage (./pkgs/ChasingBottoms.nix) { };
+  MemoTrie = f final prev "MemoTrie" (final.callPackage (./pkgs/MemoTrie.nix) { });
 
-  Diff = self.callPackage (./pkgs/Diff.nix) { };
+  MonadPrompt = f final prev "MonadPrompt" (final.callPackage (./pkgs/MonadPrompt.nix) { });
 
-  HTTP = self.callPackage (./pkgs/HTTP.nix) { };
+  NumInstances = f final prev "NumInstances" (final.callPackage (./pkgs/NumInstances.nix) { });
 
-  HUnit = self.callPackage (./pkgs/HUnit.nix) { };
+  OpenGLRaw = f final prev "OpenGLRaw" (final.callPackage (./pkgs/OpenGLRaw.nix) { });
 
-  JuicyPixels = self.callPackage (./pkgs/JuicyPixels.nix) { };
+  PyF = f final prev "PyF" (final.callPackage (./pkgs/PyF.nix) { });
 
-  MonadRandom = self.callPackage (./pkgs/MonadRandom.nix) { };
+  Stream = f final prev "Stream" (final.callPackage (./pkgs/Stream.nix) { });
 
-  OneTuple = self.callPackage (./pkgs/OneTuple.nix) { };
+  Unique = f final prev "Unique" (final.callPackage (./pkgs/Unique.nix) { });
 
-  Only = self.callPackage (./pkgs/Only.nix) { };
+  X11 = f final prev "X11" (final.callPackage (./pkgs/X11.nix) { });
 
-  OpenGLRaw = self.callPackage (./pkgs/OpenGLRaw.nix) { };
+  X11-xft = f final prev "X11-xft" (final.callPackage (./pkgs/X11-xft.nix) { });
 
-  PyF = self.callPackage (./pkgs/PyF.nix) { };
+  abstract-deque-tests = f final prev "abstract-deque-tests" (final.callPackage (./pkgs/abstract-deque-tests.nix) { });
 
-  QuickCheck = self.callPackage (./pkgs/QuickCheck.nix) { };
+  active = f final prev "active" (final.callPackage (./pkgs/active.nix) { });
 
-  adjunctions = self.callPackage (./pkgs/adjunctions.nix) { };
+  aeson-qq = f final prev "aeson-qq" (final.callPackage (./pkgs/aeson-qq.nix) { });
 
-  aeson = self.callPackage (./pkgs/aeson.nix) { };
+  aeson-yaml = f final prev "aeson-yaml" (final.callPackage (./pkgs/aeson-yaml.nix) { });
 
-  aeson-pretty = self.callPackage (./pkgs/aeson-pretty.nix) { };
+  alex = f final prev "alex" (final.callPackage (./pkgs/alex.nix) { });
 
-  aeson-yaml = self.callPackage (./pkgs/aeson-yaml.nix) { };
+  alsa-core = f final prev "alsa-core" (final.callPackage (./pkgs/alsa-core.nix) { });
 
-  ansi-terminal = self.callPackage (./pkgs/ansi-terminal.nix) { };
+  alsa-mixer = f final prev "alsa-mixer" (final.callPackage (./pkgs/alsa-mixer.nix) { });
 
-  ansi-wl-pprint = self.callPackage (./pkgs/ansi-wl-pprint.nix) { };
+  ap-normalize = f final prev "ap-normalize" (final.callPackage (./pkgs/ap-normalize.nix) { });
 
-  apecs = self.callPackage (./pkgs/apecs.nix) { };
+  apecs = f final prev "apecs" (final.callPackage (./pkgs/apecs.nix) { });
 
-  asn1-encoding = self.callPackage (./pkgs/asn1-encoding.nix) { };
+  async-timer = f final prev "async-timer" (final.callPackage (./pkgs/async-timer.nix) { });
 
-  asn1-parse = self.callPackage (./pkgs/asn1-parse.nix) { };
+  attoparsec-binary = f final prev "attoparsec-binary" (final.callPackage (./pkgs/attoparsec-binary.nix) { });
 
-  asn1-types = self.callPackage (./pkgs/asn1-types.nix) { };
+  autodocodec-servant-multipart = f final prev "autodocodec-servant-multipart" (final.callPackage (./pkgs/autodocodec-servant-multipart.nix) { });
 
-  assoc = self.callPackage (./pkgs/assoc.nix) { };
+  autoexporter = f final prev "autoexporter" (final.callPackage (./pkgs/autoexporter.nix) { });
 
-  async = self.callPackage (./pkgs/async.nix) { };
+  base-prelude = f final prev "base-prelude" (final.callPackage (./pkgs/base-prelude.nix) { });
 
-  atomic-primops = self.callPackage (./pkgs/atomic-primops.nix) { };
+  base32 = f final prev "base32" (final.callPackage (./pkgs/base32.nix) { });
 
-  attoparsec = self.callPackage (./pkgs/attoparsec.nix) { };
+  base58-bytestring = f final prev "base58-bytestring" (final.callPackage (./pkgs/base58-bytestring.nix) { });
 
-  attoparsec-binary = self.callPackage (./pkgs/attoparsec-binary.nix) { };
+  base64-bytestring-type = f final prev "base64-bytestring-type" (final.callPackage (./pkgs/base64-bytestring-type.nix) { });
 
-  attoparsec-iso8601 = self.callPackage (./pkgs/attoparsec-iso8601.nix) { };
+  beam-core = f final prev "beam-core" (final.callPackage (./pkgs/beam-core.nix) { });
 
-  autodocodec = self.callPackage (./pkgs/autodocodec.nix) { };
+  beam-migrate = f final prev "beam-migrate" (final.callPackage (./pkgs/beam-migrate.nix) { });
 
-  autodocodec-schema = self.callPackage (./pkgs/autodocodec-schema.nix) { };
+  beam-postgres = f final prev "beam-postgres" (final.callPackage (./pkgs/beam-postgres.nix) { });
 
-  autodocodec-servant-multipart = self.callPackage (./pkgs/autodocodec-servant-multipart.nix) { };
+  beam-sqlite = f final prev "beam-sqlite" (final.callPackage (./pkgs/beam-sqlite.nix) { });
 
-  autodocodec-yaml = self.callPackage (./pkgs/autodocodec-yaml.nix) { };
+  bech32 = f final prev "bech32" (final.callPackage (./pkgs/bech32.nix) { });
 
-  barbies = self.callPackage (./pkgs/barbies.nix) { };
+  bech32-th = f final prev "bech32-th" (final.callPackage (./pkgs/bech32-th.nix) { });
 
-  base-compat = self.callPackage (./pkgs/base-compat.nix) { };
+  binary-parser = f final prev "binary-parser" (final.callPackage (./pkgs/binary-parser.nix) { });
 
-  base-compat-batteries = self.callPackage (./pkgs/base-compat-batteries.nix) { };
+  blaze-svg = f final prev "blaze-svg" (final.callPackage (./pkgs/blaze-svg.nix) { });
 
-  base-orphans = self.callPackage (./pkgs/base-orphans.nix) { };
+  blaze-textual = f final prev "blaze-textual" (final.callPackage (./pkgs/blaze-textual.nix) { });
 
-  base16-bytestring = self.callPackage (./pkgs/base16-bytestring.nix) { };
+  breakpoint = f final prev "breakpoint" (final.callPackage (./pkgs/breakpoint.nix) { });
 
-  base64 = self.callPackage (./pkgs/base64.nix) { };
+  byte-order = f final prev "byte-order" (final.callPackage (./pkgs/byte-order.nix) { });
 
-  base64-bytestring = self.callPackage (./pkgs/base64-bytestring.nix) { };
+  bytebuild = f final prev "bytebuild" (final.callPackage (./pkgs/bytebuild.nix) { });
 
-  basement = self.callPackage (./pkgs/basement.nix) { };
+  byteslice = f final prev "byteslice" (final.callPackage (./pkgs/byteslice.nix) { });
 
-  bifunctors = self.callPackage (./pkgs/bifunctors.nix) { };
+  bytesmith = f final prev "bytesmith" (final.callPackage (./pkgs/bytesmith.nix) { });
 
-  bimap = self.callPackage (./pkgs/bimap.nix) { };
+  bytestring-strict-builder = f final prev "bytestring-strict-builder" (final.callPackage (./pkgs/bytestring-strict-builder.nix) { });
 
-  binary-orphans = self.callPackage (./pkgs/binary-orphans.nix) { };
+  bytestring-tree-builder = f final prev "bytestring-tree-builder" (final.callPackage (./pkgs/bytestring-tree-builder.nix) { });
 
-  bitvec = self.callPackage (./pkgs/bitvec.nix) { };
+  c2hs = f final prev "c2hs" (final.callPackage (./pkgs/c2hs.nix) { });
 
-  blaze-builder = self.callPackage (./pkgs/blaze-builder.nix) { };
+  cabal-fmt = f final prev "cabal-fmt" (final.callPackage (./pkgs/cabal-fmt.nix) { });
 
-  blaze-html = self.callPackage (./pkgs/blaze-html.nix) { };
+  cache = f final prev "cache" (final.callPackage (./pkgs/cache.nix) { });
 
-  blaze-markup = self.callPackage (./pkgs/blaze-markup.nix) { };
+  canonical-json = f final prev "canonical-json" (final.callPackage (./pkgs/canonical-json.nix) { });
 
-  blaze-textual = self.callPackage (./pkgs/blaze-textual.nix) { };
+  casing = f final prev "casing" (final.callPackage (./pkgs/casing.nix) { });
 
-  boring = self.callPackage (./pkgs/boring.nix) { };
+  cassava-megaparsec = f final prev "cassava-megaparsec" (final.callPackage (./pkgs/cassava-megaparsec.nix) { });
 
-  breakpoint = self.callPackage (./pkgs/breakpoint.nix) { };
+  cheapskate = f final prev "cheapskate" (final.callPackage (./pkgs/cheapskate.nix) { });
 
-  brick = self.callPackage (./pkgs/brick.nix) { };
+  checkers = f final prev "checkers" (final.callPackage (./pkgs/checkers.nix) { });
 
-  bsb-http-chunked = self.callPackage (./pkgs/bsb-http-chunked.nix) { };
+  chronos = f final prev "chronos" (final.callPackage (./pkgs/chronos.nix) { });
 
-  bytes = self.callPackage (./pkgs/bytes.nix) { };
+  circle-packing = f final prev "circle-packing" (final.callPackage (./pkgs/circle-packing.nix) { });
 
-  cabal-doctest = self.callPackage (./pkgs/cabal-doctest.nix) { };
+  citeproc = f final prev "citeproc" (final.callPackage (./pkgs/citeproc.nix) { });
 
-  cabal-install = self.callPackage (./pkgs/cabal-install.nix) { };
+  cmark-gfm = f final prev "cmark-gfm" (final.callPackage (./pkgs/cmark-gfm.nix) { });
 
-  cabal-install-solver = self.callPackage (./pkgs/cabal-install-solver.nix) { };
+  co-log-core = f final prev "co-log-core" (final.callPackage (./pkgs/co-log-core.nix) { });
 
-  cabal2nix = self.callPackage (./pkgs/cabal2nix.nix) { };
+  co-log-polysemy = f final prev "co-log-polysemy" (final.callPackage (./pkgs/co-log-polysemy.nix) { });
 
-  cache = self.callPackage (./pkgs/cache.nix) { };
+  colourista = f final prev "colourista" (final.callPackage (./pkgs/colourista.nix) { });
 
-  call-stack = self.callPackage (./pkgs/call-stack.nix) { };
+  commonmark = f final prev "commonmark" (final.callPackage (./pkgs/commonmark.nix) { });
 
-  case-insensitive = self.callPackage (./pkgs/case-insensitive.nix) { };
+  commonmark-extensions = f final prev "commonmark-extensions" (final.callPackage (./pkgs/commonmark-extensions.nix) { });
 
-  cassava = self.callPackage (./pkgs/cassava.nix) { };
+  commonmark-pandoc = f final prev "commonmark-pandoc" (final.callPackage (./pkgs/commonmark-pandoc.nix) { });
 
-  cassava-megaparsec = self.callPackage (./pkgs/cassava-megaparsec.nix) { };
+  commutative-semigroups = f final prev "commutative-semigroups" (final.callPackage (./pkgs/commutative-semigroups.nix) { });
 
-  cborg = self.callPackage (./pkgs/cborg.nix) { };
+  compact = f final prev "compact" (final.callPackage (./pkgs/compact.nix) { });
 
-  cborg-json = self.callPackage (./pkgs/cborg-json.nix) { };
+  compactable = f final prev "compactable" (final.callPackage (./pkgs/compactable.nix) { });
 
-  cereal = self.callPackage (./pkgs/cereal.nix) { };
+  composite-cassava = f final prev "composite-cassava" (final.callPackage (./pkgs/composite-cassava.nix) { });
 
-  charset = self.callPackage (./pkgs/charset.nix) { };
+  composite-dhall = f final prev "composite-dhall" (final.callPackage (./pkgs/composite-dhall.nix) { });
 
-  citeproc = self.callPackage (./pkgs/citeproc.nix) { };
+  composite-lens-extra = f final prev "composite-lens-extra" (final.callPackage (./pkgs/composite-lens-extra.nix) { });
 
-  clock = self.callPackage (./pkgs/clock.nix) { };
+  composite-tuple = f final prev "composite-tuple" (final.callPackage (./pkgs/composite-tuple.nix) { });
 
-  cmdargs = self.callPackage (./pkgs/cmdargs.nix) { };
+  composition-prelude = f final prev "composition-prelude" (final.callPackage (./pkgs/composition-prelude.nix) { });
 
-  co-log-core = self.callPackage (./pkgs/co-log-core.nix) { };
+  conduit-combinators = f final prev "conduit-combinators" (final.callPackage (./pkgs/conduit-combinators.nix) { });
 
-  co-log-polysemy = self.callPackage (./pkgs/co-log-polysemy.nix) { };
+  conduit-parse = f final prev "conduit-parse" (final.callPackage (./pkgs/conduit-parse.nix) { });
 
-  colour = self.callPackage (./pkgs/colour.nix) { };
+  conformance = f final prev "conformance" (final.callPackage (./pkgs/conformance.nix) { });
 
-  colourista = self.callPackage (./pkgs/colourista.nix) { };
+  conformance-gen = f final prev "conformance-gen" (final.callPackage (./pkgs/conformance-gen.nix) { });
 
-  commonmark = self.callPackage (./pkgs/commonmark.nix) { };
+  contiguous = f final prev "contiguous" (final.callPackage (./pkgs/contiguous.nix) { });
 
-  commonmark-extensions = self.callPackage (./pkgs/commonmark-extensions.nix) { };
+  contravariant-extras = f final prev "contravariant-extras" (final.callPackage (./pkgs/contravariant-extras.nix) { });
 
-  commonmark-pandoc = self.callPackage (./pkgs/commonmark-pandoc.nix) { };
+  control-monad-free = f final prev "control-monad-free" (final.callPackage (./pkgs/control-monad-free.nix) { });
 
-  comonad = self.callPackage (./pkgs/comonad.nix) { };
+  cryptonite-conduit = f final prev "cryptonite-conduit" (final.callPackage (./pkgs/cryptonite-conduit.nix) { });
 
-  compact = self.callPackage (./pkgs/compact.nix) { };
+  cursor = f final prev "cursor" (final.callPackage (./pkgs/cursor.nix) { });
 
-  compactable = self.callPackage (./pkgs/compactable.nix) { };
+  cursor-brick = f final prev "cursor-brick" (final.callPackage (./pkgs/cursor-brick.nix) { });
 
-  composite-base = self.callPackage (./pkgs/composite-base.nix) { };
+  cursor-dirforest = f final prev "cursor-dirforest" (final.callPackage (./pkgs/cursor-dirforest.nix) { });
 
-  composite-cassava = self.callPackage (./pkgs/composite-cassava.nix) { };
+  cursor-dirforest-brick = f final prev "cursor-dirforest-brick" (final.callPackage (./pkgs/cursor-dirforest-brick.nix) { });
 
-  composite-dhall = self.callPackage (./pkgs/composite-dhall.nix) { };
+  cursor-dirforest-gen = f final prev "cursor-dirforest-gen" (final.callPackage (./pkgs/cursor-dirforest-gen.nix) { });
 
-  composite-lens-extra = self.callPackage (./pkgs/composite-lens-extra.nix) { };
+  cursor-fuzzy-time = f final prev "cursor-fuzzy-time" (final.callPackage (./pkgs/cursor-fuzzy-time.nix) { });
 
-  composite-tuple = self.callPackage (./pkgs/composite-tuple.nix) { };
+  cursor-gen = f final prev "cursor-gen" (final.callPackage (./pkgs/cursor-gen.nix) { });
 
-  concurrent-output = self.callPackage (./pkgs/concurrent-output.nix) { };
+  data-bword = f final prev "data-bword" (final.callPackage (./pkgs/data-bword.nix) { });
 
-  conduit = self.callPackage (./pkgs/conduit.nix) { };
+  data-checked = f final prev "data-checked" (final.callPackage (./pkgs/data-checked.nix) { });
 
-  conduit-extra = self.callPackage (./pkgs/conduit-extra.nix) { };
+  data-dword = f final prev "data-dword" (final.callPackage (./pkgs/data-dword.nix) { });
 
-  config-ini = self.callPackage (./pkgs/config-ini.nix) { };
+  data-endian = f final prev "data-endian" (final.callPackage (./pkgs/data-endian.nix) { });
 
-  connection = self.callPackage (./pkgs/connection.nix) { };
+  data-ordlist = f final prev "data-ordlist" (final.callPackage (./pkgs/data-ordlist.nix) { });
 
-  constraints = self.callPackage (./pkgs/constraints.nix) { };
+  data-serializer = f final prev "data-serializer" (final.callPackage (./pkgs/data-serializer.nix) { });
 
-  contravariant = self.callPackage (./pkgs/contravariant.nix) { };
+  data-sketches = f final prev "data-sketches" (final.callPackage (./pkgs/data-sketches.nix) { });
 
-  criterion = self.callPackage (./pkgs/criterion.nix) { };
+  data-sketches-core = f final prev "data-sketches-core" (final.callPackage (./pkgs/data-sketches-core.nix) { });
 
-  criterion-measurement = self.callPackage (./pkgs/criterion-measurement.nix) { };
+  data-textual = f final prev "data-textual" (final.callPackage (./pkgs/data-textual.nix) { });
 
-  cryptohash = self.callPackage (./pkgs/cryptohash.nix) { };
+  dbus = f final prev "dbus" (final.callPackage (./pkgs/dbus.nix) { });
 
-  cryptohash-sha1 = self.callPackage (./pkgs/cryptohash-sha1.nix) { };
+  deferred-folds = f final prev "deferred-folds" (final.callPackage (./pkgs/deferred-folds.nix) { });
 
-  cryptohash-sha256 = self.callPackage (./pkgs/cryptohash-sha256.nix) { };
+  deque = f final prev "deque" (final.callPackage (./pkgs/deque.nix) { });
 
-  cryptonite = self.callPackage (./pkgs/cryptonite.nix) { };
+  deriving-aeson = f final prev "deriving-aeson" (final.callPackage (./pkgs/deriving-aeson.nix) { });
 
-  cursor = self.callPackage (./pkgs/cursor.nix) { };
+  dictionary-sharing = f final prev "dictionary-sharing" (final.callPackage (./pkgs/dictionary-sharing.nix) { });
 
-  cursor-brick = self.callPackage (./pkgs/cursor-brick.nix) { };
+  dimensional = f final prev "dimensional" (final.callPackage (./pkgs/dimensional.nix) { });
 
-  cursor-dirforest = self.callPackage (./pkgs/cursor-dirforest.nix) { };
+  direct-sqlite = f final prev "direct-sqlite" (final.callPackage (./pkgs/direct-sqlite.nix) { });
 
-  cursor-dirforest-brick = self.callPackage (./pkgs/cursor-dirforest-brick.nix) { };
+  dirforest = f final prev "dirforest" (final.callPackage (./pkgs/dirforest.nix) { });
 
-  cursor-dirforest-gen = self.callPackage (./pkgs/cursor-dirforest-gen.nix) { };
+  djot = f final prev "djot" (final.callPackage (./pkgs/djot.nix) { });
 
-  cursor-gen = self.callPackage (./pkgs/cursor-gen.nix) { };
+  dns = f final prev "dns" (final.callPackage (./pkgs/dns.nix) { });
 
-  daemons = self.callPackage (./pkgs/daemons.nix) { };
+  doclayout = f final prev "doclayout" (final.callPackage (./pkgs/doclayout.nix) { });
 
-  data-clist = self.callPackage (./pkgs/data-clist.nix) { };
+  doctemplates = f final prev "doctemplates" (final.callPackage (./pkgs/doctemplates.nix) { });
 
-  data-fix = self.callPackage (./pkgs/data-fix.nix) { };
+  doctest-discover = f final prev "doctest-discover" (final.callPackage (./pkgs/doctest-discover.nix) { });
 
-  data-sketches = self.callPackage (./pkgs/data-sketches.nix) { };
+  dom-lt = f final prev "dom-lt" (final.callPackage (./pkgs/dom-lt.nix) { });
 
-  data-sketches-core = self.callPackage (./pkgs/data-sketches-core.nix) { };
+  double-conversion = f final prev "double-conversion" (final.callPackage (./pkgs/double-conversion.nix) { });
 
-  dec = self.callPackage (./pkgs/dec.nix) { };
+  dual-tree = f final prev "dual-tree" (final.callPackage (./pkgs/dual-tree.nix) { });
 
-  dense-linear-algebra = self.callPackage (./pkgs/dense-linear-algebra.nix) { };
+  effectful = f final prev "effectful" (final.callPackage (./pkgs/effectful.nix) { });
 
-  deriving-aeson = self.callPackage (./pkgs/deriving-aeson.nix) { };
+  effectful-cache = f final prev "effectful-cache" (final.callPackage (./pkgs/effectful-cache.nix) { });
 
-  dhall = self.callPackage (./pkgs/dhall.nix) { };
+  effectful-core = f final prev "effectful-core" (final.callPackage (./pkgs/effectful-core.nix) { });
 
-  dhall-json = self.callPackage (./pkgs/dhall-json.nix) { };
+  ekg = f final prev "ekg" (final.callPackage (./pkgs/ekg.nix) { });
 
-  dimensional = self.callPackage (./pkgs/dimensional.nix) { };
+  ekg-core = f final prev "ekg-core" (final.callPackage (./pkgs/ekg-core.nix) { });
 
-  dirforest = self.callPackage (./pkgs/dirforest.nix) { };
+  ekg-json = f final prev "ekg-json" (final.callPackage (./pkgs/ekg-json.nix) { });
 
-  distribution-nixpkgs = self.callPackage (./pkgs/distribution-nixpkgs.nix) { };
+  ekg-statsd = f final prev "ekg-statsd" (final.callPackage (./pkgs/ekg-statsd.nix) { });
 
-  distributive = self.callPackage (./pkgs/distributive.nix) { };
+  ekg-wai = f final prev "ekg-wai" (final.callPackage (./pkgs/ekg-wai.nix) { });
 
-  dlist = self.callPackage (./pkgs/dlist.nix) { };
+  emojis = f final prev "emojis" (final.callPackage (./pkgs/emojis.nix) { });
 
-  doctemplates = self.callPackage (./pkgs/doctemplates.nix) { };
+  enclosed-exceptions = f final prev "enclosed-exceptions" (final.callPackage (./pkgs/enclosed-exceptions.nix) { });
 
-  doctest = self.callPackage (./pkgs/doctest.nix) { };
+  enummapset = f final prev "enummapset" (final.callPackage (./pkgs/enummapset.nix) { });
 
-  doctest-parallel = self.callPackage (./pkgs/doctest-parallel.nix) { };
+  exact-combinatorics = f final prev "exact-combinatorics" (final.callPackage (./pkgs/exact-combinatorics.nix) { });
 
-  double-conversion = self.callPackage (./pkgs/double-conversion.nix) { };
+  exact-pi = f final prev "exact-pi" (final.callPackage (./pkgs/exact-pi.nix) { });
 
-  echo = self.callPackage (./pkgs/echo.nix) { };
+  expiring-cache-map = f final prev "expiring-cache-map" (final.callPackage (./pkgs/expiring-cache-map.nix) { });
 
-  ed25519 = self.callPackage (./pkgs/ed25519.nix) { };
+  extended-reals = f final prev "extended-reals" (final.callPackage (./pkgs/extended-reals.nix) { });
 
-  edit-distance = self.callPackage (./pkgs/edit-distance.nix) { };
+  fast-math = f final prev "fast-math" (final.callPackage (./pkgs/fast-math.nix) { });
 
-  effectful = self.callPackage (./pkgs/effectful.nix) { };
+  fcf-containers = f final prev "fcf-containers" (final.callPackage (./pkgs/fcf-containers.nix) { });
 
-  effectful-cache = self.callPackage (./pkgs/effectful-cache.nix) { };
+  fgl = f final prev "fgl" (final.callPackage (./pkgs/fgl.nix) { });
 
-  effectful-core = self.callPackage (./pkgs/effectful-core.nix) { };
+  fgl-arbitrary = f final prev "fgl-arbitrary" (final.callPackage (./pkgs/fgl-arbitrary.nix) { });
 
-  effectful-th = self.callPackage (./pkgs/effectful-th.nix) { };
+  filelock = f final prev "filelock" (final.callPackage (./pkgs/filelock.nix) { });
 
-  either = self.callPackage (./pkgs/either.nix) { };
+  filemanip = f final prev "filemanip" (final.callPackage (./pkgs/filemanip.nix) { });
 
-  email-validate = self.callPackage (./pkgs/email-validate.nix) { };
+  filtrable = f final prev "filtrable" (final.callPackage (./pkgs/filtrable.nix) { });
 
-  enclosed-exceptions = self.callPackage (./pkgs/enclosed-exceptions.nix) { };
+  finite-field = f final prev "finite-field" (final.callPackage (./pkgs/finite-field.nix) { });
 
-  expiring-cache-map = self.callPackage (./pkgs/expiring-cache-map.nix) { };
+  finite-typelits = f final prev "finite-typelits" (final.callPackage (./pkgs/finite-typelits.nix) { });
 
-  extra = self.callPackage (./pkgs/extra.nix) { };
+  fixed = f final prev "fixed" (final.callPackage (./pkgs/fixed.nix) { });
 
-  fcf-containers = self.callPackage (./pkgs/fcf-containers.nix) { };
+  floatshow = f final prev "floatshow" (final.callPackage (./pkgs/floatshow.nix) { });
 
-  filepattern = self.callPackage (./pkgs/filepattern.nix) { };
+  fmt = f final prev "fmt" (final.callPackage (./pkgs/fmt.nix) { });
 
-  fin = self.callPackage (./pkgs/fin.nix) { };
+  focus = f final prev "focus" (final.callPackage (./pkgs/focus.nix) { });
 
-  finite-field = self.callPackage (./pkgs/finite-field.nix) { };
+  force-layout = f final prev "force-layout" (final.callPackage (./pkgs/force-layout.nix) { });
 
-  first-class-families = self.callPackage (./pkgs/first-class-families.nix) { };
+  foreign-store = f final prev "foreign-store" (final.callPackage (./pkgs/foreign-store.nix) { });
 
-  fixed = self.callPackage (./pkgs/fixed.nix) { };
+  friendly-time = f final prev "friendly-time" (final.callPackage (./pkgs/friendly-time.nix) { });
 
-  foldl = self.callPackage (./pkgs/foldl.nix) { };
+  fusion-plugin-types = f final prev "fusion-plugin-types" (final.callPackage (./pkgs/fusion-plugin-types.nix) { });
 
-  foundation = self.callPackage (./pkgs/foundation.nix) { };
+  fuzzy = f final prev "fuzzy" (final.callPackage (./pkgs/fuzzy.nix) { });
 
-  free = self.callPackage (./pkgs/free.nix) { };
+  fuzzy-time = f final prev "fuzzy-time" (final.callPackage (./pkgs/fuzzy-time.nix) { });
 
-  fsnotify = self.callPackage (./pkgs/fsnotify.nix) { };
+  fuzzy-time-gen = f final prev "fuzzy-time-gen" (final.callPackage (./pkgs/fuzzy-time-gen.nix) { });
 
-  fuzzy-time = self.callPackage (./pkgs/fuzzy-time.nix) { };
+  generic-arbitrary = f final prev "generic-arbitrary" (final.callPackage (./pkgs/generic-arbitrary.nix) { });
 
-  generic-deriving = self.callPackage (./pkgs/generic-deriving.nix) { };
+  generic-data = f final prev "generic-data" (final.callPackage (./pkgs/generic-data.nix) { });
 
-  generic-lens-core = self.callPackage (./pkgs/generic-lens-core.nix) { };
+  generic-lens = f final prev "generic-lens" (final.callPackage (./pkgs/generic-lens.nix) { });
 
-  generic-lens-lite = self.callPackage (./pkgs/generic-lens-lite.nix) { };
+  generic-lens-core = f final prev "generic-lens-core" (final.callPackage (./pkgs/generic-lens-core.nix) { });
 
-  generic-monoid = self.callPackage (./pkgs/generic-monoid.nix) { };
+  generic-lens-lite = f final prev "generic-lens-lite" (final.callPackage (./pkgs/generic-lens-lite.nix) { });
 
-  generic-optics = self.callPackage (./pkgs/generic-optics.nix) { };
+  generic-optics = f final prev "generic-optics" (final.callPackage (./pkgs/generic-optics.nix) { });
 
-  generic-optics-lite = self.callPackage (./pkgs/generic-optics-lite.nix) { };
+  generic-optics-lite = f final prev "generic-optics-lite" (final.callPackage (./pkgs/generic-optics-lite.nix) { });
 
-  generically = self.callPackage (./pkgs/generically.nix) { };
+  genvalidity-aeson = f final prev "genvalidity-aeson" (final.callPackage (./pkgs/genvalidity-aeson.nix) { });
 
-  generics-sop = self.callPackage (./pkgs/generics-sop.nix) { };
+  genvalidity-bytestring = f final prev "genvalidity-bytestring" (final.callPackage (./pkgs/genvalidity-bytestring.nix) { });
 
-  genvalidity = self.callPackage (./pkgs/genvalidity.nix) { };
+  genvalidity-case-insensitive = f final prev "genvalidity-case-insensitive" (final.callPackage (./pkgs/genvalidity-case-insensitive.nix) { });
 
-  genvalidity-aeson = self.callPackage (./pkgs/genvalidity-aeson.nix) { };
+  genvalidity-containers = f final prev "genvalidity-containers" (final.callPackage (./pkgs/genvalidity-containers.nix) { });
 
-  genvalidity-bytestring = self.callPackage (./pkgs/genvalidity-bytestring.nix) { };
+  genvalidity-criterion = f final prev "genvalidity-criterion" (final.callPackage (./pkgs/genvalidity-criterion.nix) { });
 
-  genvalidity-case-insensitive = self.callPackage (./pkgs/genvalidity-case-insensitive.nix) { };
+  genvalidity-dirforest = f final prev "genvalidity-dirforest" (final.callPackage (./pkgs/genvalidity-dirforest.nix) { });
 
-  genvalidity-containers = self.callPackage (./pkgs/genvalidity-containers.nix) { };
+  genvalidity-hspec-aeson = f final prev "genvalidity-hspec-aeson" (final.callPackage (./pkgs/genvalidity-hspec-aeson.nix) { });
 
-  genvalidity-criterion = self.callPackage (./pkgs/genvalidity-criterion.nix) { };
+  genvalidity-hspec-optics = f final prev "genvalidity-hspec-optics" (final.callPackage (./pkgs/genvalidity-hspec-optics.nix) { });
 
-  genvalidity-dirforest = self.callPackage (./pkgs/genvalidity-dirforest.nix) { };
+  genvalidity-network-uri = f final prev "genvalidity-network-uri" (final.callPackage (./pkgs/genvalidity-network-uri.nix) { });
 
-  genvalidity-hspec = self.callPackage (./pkgs/genvalidity-hspec.nix) { };
+  genvalidity-path = f final prev "genvalidity-path" (final.callPackage (./pkgs/genvalidity-path.nix) { });
 
-  genvalidity-hspec-optics = self.callPackage (./pkgs/genvalidity-hspec-optics.nix) { };
+  genvalidity-persistent = f final prev "genvalidity-persistent" (final.callPackage (./pkgs/genvalidity-persistent.nix) { });
 
-  genvalidity-path = self.callPackage (./pkgs/genvalidity-path.nix) { };
+  genvalidity-scientific = f final prev "genvalidity-scientific" (final.callPackage (./pkgs/genvalidity-scientific.nix) { });
 
-  genvalidity-persistent = self.callPackage (./pkgs/genvalidity-persistent.nix) { };
+  genvalidity-sydtest = f final prev "genvalidity-sydtest" (final.callPackage (./pkgs/genvalidity-sydtest.nix) { });
 
-  genvalidity-property = self.callPackage (./pkgs/genvalidity-property.nix) { };
+  genvalidity-sydtest-aeson = f final prev "genvalidity-sydtest-aeson" (final.callPackage (./pkgs/genvalidity-sydtest-aeson.nix) { });
 
-  genvalidity-scientific = self.callPackage (./pkgs/genvalidity-scientific.nix) { };
+  genvalidity-sydtest-hashable = f final prev "genvalidity-sydtest-hashable" (final.callPackage (./pkgs/genvalidity-sydtest-hashable.nix) { });
 
-  genvalidity-sydtest = self.callPackage (./pkgs/genvalidity-sydtest.nix) { };
+  genvalidity-sydtest-lens = f final prev "genvalidity-sydtest-lens" (final.callPackage (./pkgs/genvalidity-sydtest-lens.nix) { });
 
-  genvalidity-sydtest-aeson = self.callPackage (./pkgs/genvalidity-sydtest-aeson.nix) { };
+  genvalidity-sydtest-persistent = f final prev "genvalidity-sydtest-persistent" (final.callPackage (./pkgs/genvalidity-sydtest-persistent.nix) { });
 
-  genvalidity-sydtest-hashable = self.callPackage (./pkgs/genvalidity-sydtest-hashable.nix) { };
+  genvalidity-text = f final prev "genvalidity-text" (final.callPackage (./pkgs/genvalidity-text.nix) { });
 
-  genvalidity-sydtest-lens = self.callPackage (./pkgs/genvalidity-sydtest-lens.nix) { };
+  genvalidity-time = f final prev "genvalidity-time" (final.callPackage (./pkgs/genvalidity-time.nix) { });
 
-  genvalidity-sydtest-persistent = self.callPackage (./pkgs/genvalidity-sydtest-persistent.nix) { };
+  genvalidity-unordered-containers = f final prev "genvalidity-unordered-containers" (final.callPackage (./pkgs/genvalidity-unordered-containers.nix) { });
 
-  genvalidity-text = self.callPackage (./pkgs/genvalidity-text.nix) { };
+  genvalidity-uuid = f final prev "genvalidity-uuid" (final.callPackage (./pkgs/genvalidity-uuid.nix) { });
 
-  genvalidity-time = self.callPackage (./pkgs/genvalidity-time.nix) { };
+  genvalidity-vector = f final prev "genvalidity-vector" (final.callPackage (./pkgs/genvalidity-vector.nix) { });
 
-  genvalidity-unordered-containers = self.callPackage (./pkgs/genvalidity-unordered-containers.nix) { };
+  ghc-trace-events = f final prev "ghc-trace-events" (final.callPackage (./pkgs/ghc-trace-events.nix) { });
 
-  genvalidity-uuid = self.callPackage (./pkgs/genvalidity-uuid.nix) { };
+  ghc-typelits-knownnat = f final prev "ghc-typelits-knownnat" (final.callPackage (./pkgs/ghc-typelits-knownnat.nix) { });
 
-  genvalidity-vector = self.callPackage (./pkgs/genvalidity-vector.nix) { };
+  ghc-typelits-natnormalise = f final prev "ghc-typelits-natnormalise" (final.callPackage (./pkgs/ghc-typelits-natnormalise.nix) { });
 
-  ghc-byteorder = self.callPackage (./pkgs/ghc-byteorder.nix) { };
+  githash = f final prev "githash" (final.callPackage (./pkgs/githash.nix) { });
 
-  ghc-check = self.callPackage (./pkgs/ghc-check.nix) { };
+  graphviz = f final prev "graphviz" (final.callPackage (./pkgs/graphviz.nix) { });
 
-  ghc-exactprint = self.callPackage (./pkgs/ghc-exactprint.nix) { };
+  gridtables = f final prev "gridtables" (final.callPackage (./pkgs/gridtables.nix) { });
 
-  ghc-lib-parser = self.callPackage (./pkgs/ghc-lib-parser.nix) { };
+  haddock-library = f final prev "haddock-library" (final.callPackage (./pkgs/haddock-library.nix) { });
 
-  ghc-lib-parser-ex = self.callPackage (./pkgs/ghc-lib-parser-ex.nix) { };
+  hasql = f final prev "hasql" (final.callPackage (./pkgs/hasql.nix) { });
 
-  ghc-paths = self.callPackage (./pkgs/ghc-paths.nix) { };
+  hasql-explain-tests = f final prev "hasql-explain-tests" (final.callPackage (./pkgs/hasql-explain-tests.nix) { });
 
-  ghc-tcplugins-extra = self.callPackage (./pkgs/ghc-tcplugins-extra.nix) { };
+  hasql-migration = f final prev "hasql-migration" (final.callPackage (./pkgs/hasql-migration.nix) { });
 
-  ghc-typelits-knownnat = self.callPackage (./pkgs/ghc-typelits-knownnat.nix) { };
+  hasql-th = f final prev "hasql-th" (final.callPackage (./pkgs/hasql-th.nix) { });
 
-  ghc-typelits-natnormalise = self.callPackage (./pkgs/ghc-typelits-natnormalise.nix) { };
+  hasql-transaction = f final prev "hasql-transaction" (final.callPackage (./pkgs/hasql-transaction.nix) { });
 
-  ghcid = self.callPackage (./pkgs/ghcid.nix) { };
+  hdaemonize = f final prev "hdaemonize" (final.callPackage (./pkgs/hdaemonize.nix) { });
 
-  gitrev = self.callPackage (./pkgs/gitrev.nix) { };
+  headed-megaparsec = f final prev "headed-megaparsec" (final.callPackage (./pkgs/headed-megaparsec.nix) { });
 
-  hackage-db = self.callPackage (./pkgs/hackage-db.nix) { };
+  hedgehog-fn = f final prev "hedgehog-fn" (final.callPackage (./pkgs/hedgehog-fn.nix) { });
 
-  hackage-security = self.callPackage (./pkgs/hackage-security.nix) { };
+  hedgehog-golden = f final prev "hedgehog-golden" (final.callPackage (./pkgs/hedgehog-golden.nix) { });
 
-  haddock-library = self.callPackage (./pkgs/haddock-library.nix) { };
+  hedgehog-quickcheck = f final prev "hedgehog-quickcheck" (final.callPackage (./pkgs/hedgehog-quickcheck.nix) { });
 
-  hashable = self.callPackage (./pkgs/hashable.nix) { };
+  heredoc = f final prev "heredoc" (final.callPackage (./pkgs/heredoc.nix) { });
 
-  hashing = self.callPackage (./pkgs/hashing.nix) { };
+  hex-text = f final prev "hex-text" (final.callPackage (./pkgs/hex-text.nix) { });
 
-  hashtables = self.callPackage (./pkgs/hashtables.nix) { };
+  hoauth2 = f final prev "hoauth2" (final.callPackage (./pkgs/hoauth2.nix) { });
 
-  haskell-src-meta = self.callPackage (./pkgs/haskell-src-meta.nix) { };
+  hoauth2-providers = f final prev "hoauth2-providers" (final.callPackage (./pkgs/hoauth2-providers.nix) { });
 
-  hedgehog = self.callPackage (./pkgs/hedgehog.nix) { };
+  hosc = f final prev "hosc" (final.callPackage (./pkgs/hosc.nix) { });
 
-  hedgehog-golden = self.callPackage (./pkgs/hedgehog-golden.nix) { };
+  hslogger = f final prev "hslogger" (final.callPackage (./pkgs/hslogger.nix) { });
 
-  hie-bios = self.callPackage (./pkgs/hie-bios.nix) { };
+  hslua = f final prev "hslua" (final.callPackage (./pkgs/hslua.nix) { });
 
-  hie-compat = self.callPackage (./pkgs/hie-compat.nix) { };
+  hslua-aeson = f final prev "hslua-aeson" (final.callPackage (./pkgs/hslua-aeson.nix) { });
 
-  hiedb = self.callPackage (./pkgs/hiedb.nix) { };
+  hslua-classes = f final prev "hslua-classes" (final.callPackage (./pkgs/hslua-classes.nix) { });
 
-  hinotify = self.callPackage (./pkgs/hinotify.nix) { };
+  hslua-core = f final prev "hslua-core" (final.callPackage (./pkgs/hslua-core.nix) { });
 
-  hledger = self.callPackage (./pkgs/hledger.nix) { };
+  hslua-list = f final prev "hslua-list" (final.callPackage (./pkgs/hslua-list.nix) { });
 
-  hledger-lib = self.callPackage (./pkgs/hledger-lib.nix) { };
+  hslua-marshalling = f final prev "hslua-marshalling" (final.callPackage (./pkgs/hslua-marshalling.nix) { });
 
-  hlint = self.callPackage (./pkgs/hlint.nix) { };
+  hslua-module-doclayout = f final prev "hslua-module-doclayout" (final.callPackage (./pkgs/hslua-module-doclayout.nix) { });
 
-  hopenssl = self.callPackage (./pkgs/hopenssl.nix) { };
+  hslua-module-path = f final prev "hslua-module-path" (final.callPackage (./pkgs/hslua-module-path.nix) { });
 
-  horizon-gen-nix = self.callPackage (./pkgs/horizon-gen-nix.nix) { };
+  hslua-module-system = f final prev "hslua-module-system" (final.callPackage (./pkgs/hslua-module-system.nix) { });
 
-  hosc = self.callPackage (./pkgs/hosc.nix) { };
+  hslua-module-text = f final prev "hslua-module-text" (final.callPackage (./pkgs/hslua-module-text.nix) { });
 
-  hourglass = self.callPackage (./pkgs/hourglass.nix) { };
+  hslua-module-version = f final prev "hslua-module-version" (final.callPackage (./pkgs/hslua-module-version.nix) { });
 
-  hpack = self.callPackage (./pkgs/hpack.nix) { };
+  hslua-objectorientation = f final prev "hslua-objectorientation" (final.callPackage (./pkgs/hslua-objectorientation.nix) { });
 
-  hpack-dhall = self.callPackage (./pkgs/hpack-dhall.nix) { };
+  hslua-packaging = f final prev "hslua-packaging" (final.callPackage (./pkgs/hslua-packaging.nix) { });
 
-  hslua = self.callPackage (./pkgs/hslua.nix) { };
+  hslua-typing = f final prev "hslua-typing" (final.callPackage (./pkgs/hslua-typing.nix) { });
 
-  hslua-aeson = self.callPackage (./pkgs/hslua-aeson.nix) { };
+  hspec-attoparsec = f final prev "hspec-attoparsec" (final.callPackage (./pkgs/hspec-attoparsec.nix) { });
 
-  hslua-classes = self.callPackage (./pkgs/hslua-classes.nix) { };
+  hspec-contrib = f final prev "hspec-contrib" (final.callPackage (./pkgs/hspec-contrib.nix) { });
 
-  hslua-core = self.callPackage (./pkgs/hslua-core.nix) { };
+  hspec-golden = f final prev "hspec-golden" (final.callPackage (./pkgs/hspec-golden.nix) { });
 
-  hslua-marshalling = self.callPackage (./pkgs/hslua-marshalling.nix) { };
+  hspec-golden-aeson = f final prev "hspec-golden-aeson" (final.callPackage (./pkgs/hspec-golden-aeson.nix) { });
 
-  hslua-module-doclayout = self.callPackage (./pkgs/hslua-module-doclayout.nix) { };
+  hsyslog = f final prev "hsyslog" (final.callPackage (./pkgs/hsyslog.nix) { });
 
-  hslua-module-path = self.callPackage (./pkgs/hslua-module-path.nix) { };
+  html = f final prev "html" (final.callPackage (./pkgs/html.nix) { });
 
-  hslua-module-system = self.callPackage (./pkgs/hslua-module-system.nix) { };
+  hw-fingertree = f final prev "hw-fingertree" (final.callPackage (./pkgs/hw-fingertree.nix) { });
 
-  hslua-module-text = self.callPackage (./pkgs/hslua-module-text.nix) { };
+  hw-hedgehog = f final prev "hw-hedgehog" (final.callPackage (./pkgs/hw-hedgehog.nix) { });
 
-  hslua-module-version = self.callPackage (./pkgs/hslua-module-version.nix) { };
+  hw-hspec-hedgehog = f final prev "hw-hspec-hedgehog" (final.callPackage (./pkgs/hw-hspec-hedgehog.nix) { });
 
-  hslua-objectorientation = self.callPackage (./pkgs/hslua-objectorientation.nix) { };
+  hw-prim = f final prev "hw-prim" (final.callPackage (./pkgs/hw-prim.nix) { });
 
-  hslua-packaging = self.callPackage (./pkgs/hslua-packaging.nix) { };
+  ical = f final prev "ical" (final.callPackage (./pkgs/ical.nix) { });
 
-  hspec = self.callPackage (./pkgs/hspec.nix) { };
+  ical-gen = f final prev "ical-gen" (final.callPackage (./pkgs/ical-gen.nix) { });
 
-  hspec-contrib = self.callPackage (./pkgs/hspec-contrib.nix) { };
+  ical-interop-test = f final prev "ical-interop-test" (final.callPackage (./pkgs/ical-interop-test.nix) { });
 
-  hspec-core = self.callPackage (./pkgs/hspec-core.nix) { };
+  ical-recurrence = f final prev "ical-recurrence" (final.callPackage (./pkgs/ical-recurrence.nix) { });
 
-  hspec-discover = self.callPackage (./pkgs/hspec-discover.nix) { };
+  ical-recurrence-gen = f final prev "ical-recurrence-gen" (final.callPackage (./pkgs/ical-recurrence-gen.nix) { });
 
-  hspec-megaparsec = self.callPackage (./pkgs/hspec-megaparsec.nix) { };
+  indexed-list-literals = f final prev "indexed-list-literals" (final.callPackage (./pkgs/indexed-list-literals.nix) { });
 
-  hspec-meta = self.callPackage (./pkgs/hspec-meta.nix) { };
+  inline-c = f final prev "inline-c" (final.callPackage (./pkgs/inline-c.nix) { });
 
-  http-api-data = self.callPackage (./pkgs/http-api-data.nix) { };
+  int-cast = f final prev "int-cast" (final.callPackage (./pkgs/int-cast.nix) { });
 
-  http-client = self.callPackage (./pkgs/http-client.nix) { };
+  integration = f final prev "integration" (final.callPackage (./pkgs/integration.nix) { });
 
-  http-client-tls = self.callPackage (./pkgs/http-client-tls.nix) { };
+  intervals = f final prev "intervals" (final.callPackage (./pkgs/intervals.nix) { });
 
-  http-date = self.callPackage (./pkgs/http-date.nix) { };
+  ipynb = f final prev "ipynb" (final.callPackage (./pkgs/ipynb.nix) { });
 
-  http-media = self.callPackage (./pkgs/http-media.nix) { };
+  iso8601-time = f final prev "iso8601-time" (final.callPackage (./pkgs/iso8601-time.nix) { });
 
-  http-types = self.callPackage (./pkgs/http-types.nix) { };
+  isomorphism-class = f final prev "isomorphism-class" (final.callPackage (./pkgs/isomorphism-class.nix) { });
 
-  http2 = self.callPackage (./pkgs/http2.nix) { };
+  iwlib = f final prev "iwlib" (final.callPackage (./pkgs/iwlib.nix) { });
 
-  httpd-shed = self.callPackage (./pkgs/httpd-shed.nix) { };
+  jira-wiki-markup = f final prev "jira-wiki-markup" (final.callPackage (./pkgs/jira-wiki-markup.nix) { });
 
-  incipit-base = self.callPackage (./pkgs/incipit-base.nix) { };
+  katip = f final prev "katip" (final.callPackage (./pkgs/katip.nix) { });
 
-  incipit-core = self.callPackage (./pkgs/incipit-core.nix) { };
+  language-c = f final prev "language-c" (final.callPackage (./pkgs/language-c.nix) { });
 
-  indexed-traversable = self.callPackage (./pkgs/indexed-traversable.nix) { };
+  lazy-search = f final prev "lazy-search" (final.callPackage (./pkgs/lazy-search.nix) { });
 
-  indexed-traversable-instances = self.callPackage (./pkgs/indexed-traversable-instances.nix) { };
+  lazysmallcheck = f final prev "lazysmallcheck" (final.callPackage (./pkgs/lazysmallcheck.nix) { });
 
-  infer-license = self.callPackage (./pkgs/infer-license.nix) { };
+  libsodium-bindings = f final prev "libsodium-bindings" (final.callPackage (./pkgs/libsodium-bindings.nix) { });
 
-  insert-ordered-containers = self.callPackage (./pkgs/insert-ordered-containers.nix) { };
+  libsystemd-journal = f final prev "libsystemd-journal" (final.callPackage (./pkgs/libsystemd-journal.nix) { });
 
-  inspection-testing = self.callPackage (./pkgs/inspection-testing.nix) { };
+  linear-base = f final prev "linear-base" (final.callPackage (./pkgs/linear-base.nix) { });
 
-  integer-logarithms = self.callPackage (./pkgs/integer-logarithms.nix) { };
+  linear-generics = f final prev "linear-generics" (final.callPackage (./pkgs/linear-generics.nix) { });
 
-  invariant = self.callPackage (./pkgs/invariant.nix) { };
+  list-transformer = f final prev "list-transformer" (final.callPackage (./pkgs/list-transformer.nix) { });
 
-  iproute = self.callPackage (./pkgs/iproute.nix) { };
+  lockfree-queue = f final prev "lockfree-queue" (final.callPackage (./pkgs/lockfree-queue.nix) { });
 
-  ipynb = self.callPackage (./pkgs/ipynb.nix) { };
+  log-base = f final prev "log-base" (final.callPackage (./pkgs/log-base.nix) { });
 
-  kan-extensions = self.callPackage (./pkgs/kan-extensions.nix) { };
+  log-effectful = f final prev "log-effectful" (final.callPackage (./pkgs/log-effectful.nix) { });
 
-  keys = self.callPackage (./pkgs/keys.nix) { };
+  loop = f final prev "loop" (final.callPackage (./pkgs/loop.nix) { });
 
-  kvstore-effectful = self.callPackage (./pkgs/kvstore-effectful.nix) { };
+  lpeg = f final prev "lpeg" (final.callPackage (./pkgs/lpeg.nix) { });
 
-  kvstore-effectful-cache = self.callPackage (./pkgs/kvstore-effectful-cache.nix) { };
+  lrucache = f final prev "lrucache" (final.callPackage (./pkgs/lrucache.nix) { });
 
-  kvstore-effectful-spec = self.callPackage (./pkgs/kvstore-effectful-spec.nix) { };
+  lua = f final prev "lua" (final.callPackage (./pkgs/lua.nix) { });
 
-  kvstore-effectful-statemap = self.callPackage (./pkgs/kvstore-effectful-statemap.nix) { };
+  lua-arbitrary = f final prev "lua-arbitrary" (final.callPackage (./pkgs/lua-arbitrary.nix) { });
 
-  language-nix = self.callPackage (./pkgs/language-nix.nix) { };
+  lucid-alpine = f final prev "lucid-alpine" (final.callPackage (./pkgs/lucid-alpine.nix) { });
 
-  lens = self.callPackage (./pkgs/lens.nix) { };
+  lucid-aria = f final prev "lucid-aria" (final.callPackage (./pkgs/lucid-aria.nix) { });
 
-  lens-aeson = self.callPackage (./pkgs/lens-aeson.nix) { };
+  lucid-svg = f final prev "lucid-svg" (final.callPackage (./pkgs/lucid-svg.nix) { });
 
-  lens-family-th = self.callPackage (./pkgs/lens-family-th.nix) { };
+  lvar = f final prev "lvar" (final.callPackage (./pkgs/lvar.nix) { });
 
-  libsodium = self.callPackage (./pkgs/libsodium.nix) { };
+  markdown = f final prev "markdown" (final.callPackage (./pkgs/markdown.nix) { });
 
-  libyaml = self.callPackage (./pkgs/libyaml.nix) { };
+  markov-chain-usage-model = f final prev "markov-chain-usage-model" (final.callPackage (./pkgs/markov-chain-usage-model.nix) { });
 
-  lifted-async = self.callPackage (./pkgs/lifted-async.nix) { };
+  matrices = f final prev "matrices" (final.callPackage (./pkgs/matrices.nix) { });
 
-  lifted-base = self.callPackage (./pkgs/lifted-base.nix) { };
+  matrix = f final prev "matrix" (final.callPackage (./pkgs/matrix.nix) { });
 
-  linear = self.callPackage (./pkgs/linear.nix) { };
+  mersenne-random-pure64 = f final prev "mersenne-random-pure64" (final.callPackage (./pkgs/mersenne-random-pure64.nix) { });
 
-  log-base = self.callPackage (./pkgs/log-base.nix) { };
+  mfsolve = f final prev "mfsolve" (final.callPackage (./pkgs/mfsolve.nix) { });
 
-  log-effectful = self.callPackage (./pkgs/log-effectful.nix) { };
+  microbench = f final prev "microbench" (final.callPackage (./pkgs/microbench.nix) { });
 
-  lpeg = self.callPackage (./pkgs/lpeg.nix) { };
+  microlens-aeson = f final prev "microlens-aeson" (final.callPackage (./pkgs/microlens-aeson.nix) { });
 
-  lsp = self.callPackage (./pkgs/lsp.nix) { };
+  microlens-ghc = f final prev "microlens-ghc" (final.callPackage (./pkgs/microlens-ghc.nix) { });
 
-  lsp-types = self.callPackage (./pkgs/lsp-types.nix) { };
+  microlens-platform = f final prev "microlens-platform" (final.callPackage (./pkgs/microlens-platform.nix) { });
 
-  lua = self.callPackage (./pkgs/lua.nix) { };
+  microspec = f final prev "microspec" (final.callPackage (./pkgs/microspec.nix) { });
 
-  lua-arbitrary = self.callPackage (./pkgs/lua-arbitrary.nix) { };
+  mime-mail = f final prev "mime-mail" (final.callPackage (./pkgs/mime-mail.nix) { });
 
-  lucid = self.callPackage (./pkgs/lucid.nix) { };
+  mod = f final prev "mod" (final.callPackage (./pkgs/mod.nix) { });
 
-  lucid-alpine = self.callPackage (./pkgs/lucid-alpine.nix) { };
+  monad-time-effectful = f final prev "monad-time-effectful" (final.callPackage (./pkgs/monad-time-effectful.nix) { });
 
-  lucid-aria = self.callPackage (./pkgs/lucid-aria.nix) { };
+  monoid-extras = f final prev "monoid-extras" (final.callPackage (./pkgs/monoid-extras.nix) { });
 
-  lucid-svg = self.callPackage (./pkgs/lucid-svg.nix) { };
+  monoid-subclasses = f final prev "monoid-subclasses" (final.callPackage (./pkgs/monoid-subclasses.nix) { });
 
-  lukko = self.callPackage (./pkgs/lukko.nix) { };
+  mtl-prelude = f final prev "mtl-prelude" (final.callPackage (./pkgs/mtl-prelude.nix) { });
 
-  markdown-unlit = self.callPackage (./pkgs/markdown-unlit.nix) { };
+  multiset = f final prev "multiset" (final.callPackage (./pkgs/multiset.nix) { });
 
-  math-functions = self.callPackage (./pkgs/math-functions.nix) { };
+  natural-arithmetic = f final prev "natural-arithmetic" (final.callPackage (./pkgs/natural-arithmetic.nix) { });
 
-  megaparsec = self.callPackage (./pkgs/megaparsec.nix) { };
+  natural-transformation = f final prev "natural-transformation" (final.callPackage (./pkgs/natural-transformation.nix) { });
 
-  memory = self.callPackage (./pkgs/memory.nix) { };
+  network-conduit-tls = f final prev "network-conduit-tls" (final.callPackage (./pkgs/network-conduit-tls.nix) { });
 
-  microlens = self.callPackage (./pkgs/microlens.nix) { };
+  network-ip = f final prev "network-ip" (final.callPackage (./pkgs/network-ip.nix) { });
 
-  microlens-aeson = self.callPackage (./pkgs/microlens-aeson.nix) { };
+  newtype-generics = f final prev "newtype-generics" (final.callPackage (./pkgs/newtype-generics.nix) { });
 
-  microlens-mtl = self.callPackage (./pkgs/microlens-mtl.nix) { };
+  non-negative = f final prev "non-negative" (final.callPackage (./pkgs/non-negative.nix) { });
 
-  microlens-th = self.callPackage (./pkgs/microlens-th.nix) { };
+  nonempty-vector = f final prev "nonempty-vector" (final.callPackage (./pkgs/nonempty-vector.nix) { });
 
-  microstache = self.callPackage (./pkgs/microstache.nix) { };
+  numeric-extras = f final prev "numeric-extras" (final.callPackage (./pkgs/numeric-extras.nix) { });
 
-  mockery = self.callPackage (./pkgs/mockery.nix) { };
+  numeric-prelude = f final prev "numeric-prelude" (final.callPackage (./pkgs/numeric-prelude.nix) { });
 
-  mod = self.callPackage (./pkgs/mod.nix) { };
+  numtype-dk = f final prev "numtype-dk" (final.callPackage (./pkgs/numtype-dk.nix) { });
 
-  monad-control = self.callPackage (./pkgs/monad-control.nix) { };
+  odd-jobs = f final prev "odd-jobs" (final.callPackage (./pkgs/odd-jobs.nix) { });
 
-  monad-logger = self.callPackage (./pkgs/monad-logger.nix) { };
+  one-liner = f final prev "one-liner" (final.callPackage (./pkgs/one-liner.nix) { });
 
-  monad-par = self.callPackage (./pkgs/monad-par.nix) { };
+  one-time-password = f final prev "one-time-password" (final.callPackage (./pkgs/one-time-password.nix) { });
 
-  monad-par-extras = self.callPackage (./pkgs/monad-par-extras.nix) { };
+  opentelemetry = f final prev "opentelemetry" (final.callPackage (./pkgs/opentelemetry.nix) { });
 
-  monad-time = self.callPackage (./pkgs/monad-time.nix) { };
+  operational = f final prev "operational" (final.callPackage (./pkgs/operational.nix) { });
 
-  mono-traversable = self.callPackage (./pkgs/mono-traversable.nix) { };
+  optparse-generic = f final prev "optparse-generic" (final.callPackage (./pkgs/optparse-generic.nix) { });
 
-  monoid-subclasses = self.callPackage (./pkgs/monoid-subclasses.nix) { };
+  optparse-simple = f final prev "optparse-simple" (final.callPackage (./pkgs/optparse-simple.nix) { });
 
-  mwc-random = self.callPackage (./pkgs/mwc-random.nix) { };
+  ordered-containers = f final prev "ordered-containers" (final.callPackage (./pkgs/ordered-containers.nix) { });
 
-  nanospec = self.callPackage (./pkgs/nanospec.nix) { };
+  pager = f final prev "pager" (final.callPackage (./pkgs/pager.nix) { });
 
-  net-mqtt = self.callPackage (./pkgs/net-mqtt.nix) { };
+  pandoc-lua-marshal = f final prev "pandoc-lua-marshal" (final.callPackage (./pkgs/pandoc-lua-marshal.nix) { });
 
-  network = self.callPackage (./pkgs/network.nix) { };
+  pandoc-types = f final prev "pandoc-types" (final.callPackage (./pkgs/pandoc-types.nix) { });
 
-  network-byte-order = self.callPackage (./pkgs/network-byte-order.nix) { };
+  parsec-numbers = f final prev "parsec-numbers" (final.callPackage (./pkgs/parsec-numbers.nix) { });
 
-  network-conduit-tls = self.callPackage (./pkgs/network-conduit-tls.nix) { };
+  parsec1 = f final prev "parsec1" (final.callPackage (./pkgs/parsec1.nix) { });
 
-  network-uri = self.callPackage (./pkgs/network-uri.nix) { };
+  parsers-megaparsec = f final prev "parsers-megaparsec" (final.callPackage (./pkgs/parsers-megaparsec.nix) { });
 
-  newtype-generics = self.callPackage (./pkgs/newtype-generics.nix) { };
+  partial-order = f final prev "partial-order" (final.callPackage (./pkgs/partial-order.nix) { });
 
-  nothunks = self.callPackage (./pkgs/nothunks.nix) { };
+  password = f final prev "password" (final.callPackage (./pkgs/password.nix) { });
 
-  odd-jobs = self.callPackage (./pkgs/odd-jobs.nix) { };
+  password-types = f final prev "password-types" (final.callPackage (./pkgs/password-types.nix) { });
 
-  old-locale = self.callPackage (./pkgs/old-locale.nix) { };
+  pcre-heavy = f final prev "pcre-heavy" (final.callPackage (./pkgs/pcre-heavy.nix) { });
 
-  optics = self.callPackage (./pkgs/optics.nix) { };
+  pcre2 = f final prev "pcre2" (final.callPackage (./pkgs/pcre2.nix) { });
 
-  optics-core = self.callPackage (./pkgs/optics-core.nix) { };
+  pg-entity = f final prev "pg-entity" (final.callPackage (./pkgs/pg-entity.nix) { });
 
-  optics-extra = self.callPackage (./pkgs/optics-extra.nix) { };
+  pg-transact = f final prev "pg-transact" (final.callPackage (./pkgs/pg-transact.nix) { });
 
-  optics-th = self.callPackage (./pkgs/optics-th.nix) { };
+  pg-transact-effectful = f final prev "pg-transact-effectful" (final.callPackage (./pkgs/pg-transact-effectful.nix) { });
 
-  optparse-applicative = self.callPackage (./pkgs/optparse-applicative.nix) { };
+  pipes-safe = f final prev "pipes-safe" (final.callPackage (./pkgs/pipes-safe.nix) { });
 
-  pandoc = self.callPackage (./pkgs/pandoc.nix) { };
+  polysemy-extra = f final prev "polysemy-extra" (final.callPackage (./pkgs/polysemy-extra.nix) { });
 
-  pandoc-lua-marshal = self.callPackage (./pkgs/pandoc-lua-marshal.nix) { };
+  polysemy-kvstore = f final prev "polysemy-kvstore" (final.callPackage (./pkgs/polysemy-kvstore.nix) { });
 
-  pandoc-types = self.callPackage (./pkgs/pandoc-types.nix) { };
+  polysemy-methodology = f final prev "polysemy-methodology" (final.callPackage (./pkgs/polysemy-methodology.nix) { });
 
-  parallel = self.callPackage (./pkgs/parallel.nix) { };
+  polysemy-path = f final prev "polysemy-path" (final.callPackage (./pkgs/polysemy-path.nix) { });
 
-  parsers = self.callPackage (./pkgs/parsers.nix) { };
+  polysemy-several = f final prev "polysemy-several" (final.callPackage (./pkgs/polysemy-several.nix) { });
 
-  password = self.callPackage (./pkgs/password.nix) { };
+  polysemy-vinyl = f final prev "polysemy-vinyl" (final.callPackage (./pkgs/polysemy-vinyl.nix) { });
 
-  password-types = self.callPackage (./pkgs/password-types.nix) { };
+  polysemy-zoo = f final prev "polysemy-zoo" (final.callPackage (./pkgs/polysemy-zoo.nix) { });
 
-  path = self.callPackage (./pkgs/path.nix) { };
+  poolboy = f final prev "poolboy" (final.callPackage (./pkgs/poolboy.nix) { });
 
-  path-dhall-instance = self.callPackage (./pkgs/path-dhall-instance.nix) { };
+  postgresql-binary = f final prev "postgresql-binary" (final.callPackage (./pkgs/postgresql-binary.nix) { });
 
-  path-io = self.callPackage (./pkgs/path-io.nix) { };
+  postgresql-migration = f final prev "postgresql-migration" (final.callPackage (./pkgs/postgresql-migration.nix) { });
 
-  pcg-random = self.callPackage (./pkgs/pcg-random.nix) { };
+  postgresql-simple-migration = f final prev "postgresql-simple-migration" (final.callPackage (./pkgs/postgresql-simple-migration.nix) { });
 
-  pcre2 = self.callPackage (./pkgs/pcre2.nix) { };
+  postgresql-syntax = f final prev "postgresql-syntax" (final.callPackage (./pkgs/postgresql-syntax.nix) { });
 
-  pem = self.callPackage (./pkgs/pem.nix) { };
+  pqueue = f final prev "pqueue" (final.callPackage (./pkgs/pqueue.nix) { });
 
-  persistent = self.callPackage (./pkgs/persistent.nix) { };
+  pretty-relative-time = f final prev "pretty-relative-time" (final.callPackage (./pkgs/pretty-relative-time.nix) { });
 
-  pg-entity = self.callPackage (./pkgs/pg-entity.nix) { };
+  primes = f final prev "primes" (final.callPackage (./pkgs/primes.nix) { });
 
-  pg-transact = self.callPackage (./pkgs/pg-transact.nix) { };
+  primitive-offset = f final prev "primitive-offset" (final.callPackage (./pkgs/primitive-offset.nix) { });
 
-  pg-transact-effectful = self.callPackage (./pkgs/pg-transact-effectful.nix) { };
+  primitive-unaligned = f final prev "primitive-unaligned" (final.callPackage (./pkgs/primitive-unaligned.nix) { });
 
-  pointed = self.callPackage (./pkgs/pointed.nix) { };
+  primitive-unlifted = f final prev "primitive-unlifted" (final.callPackage (./pkgs/primitive-unlifted.nix) { });
 
-  polysemy = self.callPackage (./pkgs/polysemy.nix) { };
+  prometheus-client = f final prev "prometheus-client" (final.callPackage (./pkgs/prometheus-client.nix) { });
 
-  polysemy-extra = self.callPackage (./pkgs/polysemy-extra.nix) { };
+  prometheus-metrics-ghc = f final prev "prometheus-metrics-ghc" (final.callPackage (./pkgs/prometheus-metrics-ghc.nix) { });
 
-  polysemy-kvstore = self.callPackage (./pkgs/polysemy-kvstore.nix) { };
+  prometheus-proc = f final prev "prometheus-proc" (final.callPackage (./pkgs/prometheus-proc.nix) { });
 
-  polysemy-methodology = self.callPackage (./pkgs/polysemy-methodology.nix) { };
+  proteaaudio-sdl = f final prev "proteaaudio-sdl" (final.callPackage (./pkgs/proteaaudio-sdl.nix) { });
 
-  polysemy-path = self.callPackage (./pkgs/polysemy-path.nix) { };
+  qrcode-core = f final prev "qrcode-core" (final.callPackage (./pkgs/qrcode-core.nix) { });
 
-  polysemy-plugin = self.callPackage (./pkgs/polysemy-plugin.nix) { };
+  qrcode-juicypixels = f final prev "qrcode-juicypixels" (final.callPackage (./pkgs/qrcode-juicypixels.nix) { });
 
-  polysemy-several = self.callPackage (./pkgs/polysemy-several.nix) { };
+  quickcheck-arbitrary-adt = f final prev "quickcheck-arbitrary-adt" (final.callPackage (./pkgs/quickcheck-arbitrary-adt.nix) { });
 
-  polysemy-time = self.callPackage (./pkgs/polysemy-time.nix) { };
+  quickcheck-assertions = f final prev "quickcheck-assertions" (final.callPackage (./pkgs/quickcheck-assertions.nix) { });
 
-  polysemy-vinyl = self.callPackage (./pkgs/polysemy-vinyl.nix) { };
+  quote-quot = f final prev "quote-quot" (final.callPackage (./pkgs/quote-quot.nix) { });
 
-  polysemy-zoo = self.callPackage (./pkgs/polysemy-zoo.nix) { };
+  random-fu = f final prev "random-fu" (final.callPackage (./pkgs/random-fu.nix) { });
 
-  postgresql-libpq = self.callPackage (./pkgs/postgresql-libpq.nix) { };
+  raven-haskell = f final prev "raven-haskell" (final.callPackage (./pkgs/raven-haskell.nix) { });
 
-  postgresql-migration = self.callPackage (./pkgs/postgresql-migration.nix) { };
+  refact = f final prev "refact" (final.callPackage (./pkgs/refact.nix) { });
 
-  postgresql-simple = self.callPackage (./pkgs/postgresql-simple.nix) { };
+  refined = f final prev "refined" (final.callPackage (./pkgs/refined.nix) { });
 
-  postgresql-simple-migration = self.callPackage (./pkgs/postgresql-simple-migration.nix) { };
+  regex = f final prev "regex" (final.callPackage (./pkgs/regex.nix) { });
 
-  pretty-show = self.callPackage (./pkgs/pretty-show.nix) { };
+  regex-applicative = f final prev "regex-applicative" (final.callPackage (./pkgs/regex-applicative.nix) { });
 
-  pretty-simple = self.callPackage (./pkgs/pretty-simple.nix) { };
+  regex-pcre-builtin = f final prev "regex-pcre-builtin" (final.callPackage (./pkgs/regex-pcre-builtin.nix) { });
 
-  prettyprinter-ansi-terminal = self.callPackage (./pkgs/prettyprinter-ansi-terminal.nix) { };
+  replace-megaparsec = f final prev "replace-megaparsec" (final.callPackage (./pkgs/replace-megaparsec.nix) { });
 
-  primitive = self.callPackage (./pkgs/primitive.nix) { };
+  req = f final prev "req" (final.callPackage (./pkgs/req.nix) { });
 
-  primitive-addr = self.callPackage (./pkgs/primitive-addr.nix) { };
+  rope-utf16-splay = f final prev "rope-utf16-splay" (final.callPackage (./pkgs/rope-utf16-splay.nix) { });
 
-  profunctors = self.callPackage (./pkgs/profunctors.nix) { };
+  row-types = f final prev "row-types" (final.callPackage (./pkgs/row-types.nix) { });
 
-  prometheus-client = self.callPackage (./pkgs/prometheus-client.nix) { };
+  run-st = f final prev "run-st" (final.callPackage (./pkgs/run-st.nix) { });
 
-  prometheus-proc = self.callPackage (./pkgs/prometheus-proc.nix) { };
+  rvar = f final prev "rvar" (final.callPackage (./pkgs/rvar.nix) { });
 
-  proteaaudio-sdl = self.callPackage (./pkgs/proteaaudio-sdl.nix) { };
+  sandwich = f final prev "sandwich" (final.callPackage (./pkgs/sandwich.nix) { });
 
-  psqueues = self.callPackage (./pkgs/psqueues.nix) { };
+  say = f final prev "say" (final.callPackage (./pkgs/say.nix) { });
 
-  pureMD5 = self.callPackage (./pkgs/pureMD5.nix) { };
+  scotty = f final prev "scotty" (final.callPackage (./pkgs/scotty.nix) { });
 
-  quickcheck-classes = self.callPackage (./pkgs/quickcheck-classes.nix) { };
+  sel = f final prev "sel" (final.callPackage (./pkgs/sel.nix) { });
 
-  quickcheck-classes-base = self.callPackage (./pkgs/quickcheck-classes-base.nix) { };
+  semver = f final prev "semver" (final.callPackage (./pkgs/semver.nix) { });
 
-  quickcheck-dynamic = self.callPackage (./pkgs/quickcheck-dynamic.nix) { };
+  servant-blaze = f final prev "servant-blaze" (final.callPackage (./pkgs/servant-blaze.nix) { });
 
-  quickcheck-instances = self.callPackage (./pkgs/quickcheck-instances.nix) { };
+  servant-effectful = f final prev "servant-effectful" (final.callPackage (./pkgs/servant-effectful.nix) { });
 
-  quickcheck-unicode = self.callPackage (./pkgs/quickcheck-unicode.nix) { };
+  servant-lucid = f final prev "servant-lucid" (final.callPackage (./pkgs/servant-lucid.nix) { });
 
-  random = self.callPackage (./pkgs/random.nix) { };
+  servant-openapi3 = f final prev "servant-openapi3" (final.callPackage (./pkgs/servant-openapi3.nix) { });
 
-  random-bytestring = self.callPackage (./pkgs/random-bytestring.nix) { };
+  servant-static-th = f final prev "servant-static-th" (final.callPackage (./pkgs/servant-static-th.nix) { });
 
-  random-shuffle = self.callPackage (./pkgs/random-shuffle.nix) { };
+  servant-websockets = f final prev "servant-websockets" (final.callPackage (./pkgs/servant-websockets.nix) { });
 
-  rebase = self.callPackage (./pkgs/rebase.nix) { };
+  setlocale = f final prev "setlocale" (final.callPackage (./pkgs/setlocale.nix) { });
 
-  reducers = self.callPackage (./pkgs/reducers.nix) { };
+  shelly = f final prev "shelly" (final.callPackage (./pkgs/shelly.nix) { });
 
-  refined = self.callPackage (./pkgs/refined.nix) { };
+  show-combinators = f final prev "show-combinators" (final.callPackage (./pkgs/show-combinators.nix) { });
 
-  reflection = self.callPackage (./pkgs/reflection.nix) { };
+  shower = f final prev "shower" (final.callPackage (./pkgs/shower.nix) { });
 
-  regex-applicative = self.callPackage (./pkgs/regex-applicative.nix) { };
+  singletons = f final prev "singletons" (final.callPackage (./pkgs/singletons.nix) { });
 
-  regex-base = self.callPackage (./pkgs/regex-base.nix) { };
+  size-based = f final prev "size-based" (final.callPackage (./pkgs/size-based.nix) { });
 
-  regex-posix = self.callPackage (./pkgs/regex-posix.nix) { };
+  skylighting = f final prev "skylighting" (final.callPackage (./pkgs/skylighting.nix) { });
 
-  regex-tdfa = self.callPackage (./pkgs/regex-tdfa.nix) { };
+  skylighting-core = f final prev "skylighting-core" (final.callPackage (./pkgs/skylighting-core.nix) { });
 
-  relude = self.callPackage (./pkgs/relude.nix) { };
+  skylighting-format-ansi = f final prev "skylighting-format-ansi" (final.callPackage (./pkgs/skylighting-format-ansi.nix) { });
 
-  rere = self.callPackage (./pkgs/rere.nix) { };
+  skylighting-format-blaze-html = f final prev "skylighting-format-blaze-html" (final.callPackage (./pkgs/skylighting-format-blaze-html.nix) { });
 
-  rerebase = self.callPackage (./pkgs/rerebase.nix) { };
+  skylighting-format-context = f final prev "skylighting-format-context" (final.callPackage (./pkgs/skylighting-format-context.nix) { });
 
-  resolv = self.callPackage (./pkgs/resolv.nix) { };
+  skylighting-format-latex = f final prev "skylighting-format-latex" (final.callPackage (./pkgs/skylighting-format-latex.nix) { });
 
-  resource-pool = self.callPackage (./pkgs/resource-pool.nix) { };
+  slugify = f final prev "slugify" (final.callPackage (./pkgs/slugify.nix) { });
 
-  resourcet = self.callPackage (./pkgs/resourcet.nix) { };
+  sort = f final prev "sort" (final.callPackage (./pkgs/sort.nix) { });
 
-  retry = self.callPackage (./pkgs/retry.nix) { };
+  sorted-list = f final prev "sorted-list" (final.callPackage (./pkgs/sorted-list.nix) { });
 
-  rope-utf16-splay = self.callPackage (./pkgs/rope-utf16-splay.nix) { };
+  souffle-haskell = f final prev "souffle-haskell" (final.callPackage (./pkgs/souffle-haskell.nix) { });
 
-  safe-coloured-text = self.callPackage (./pkgs/safe-coloured-text.nix) { };
+  sourcemap = f final prev "sourcemap" (final.callPackage (./pkgs/sourcemap.nix) { });
 
-  safe-coloured-text-terminfo = self.callPackage (./pkgs/safe-coloured-text-terminfo.nix) { };
+  sqlite-simple = f final prev "sqlite-simple" (final.callPackage (./pkgs/sqlite-simple.nix) { });
 
-  safe-exceptions = self.callPackage (./pkgs/safe-exceptions.nix) { };
+  statestack = f final prev "statestack" (final.callPackage (./pkgs/statestack.nix) { });
 
-  saltine = self.callPackage (./pkgs/saltine.nix) { };
+  statistics-linreg = f final prev "statistics-linreg" (final.callPackage (./pkgs/statistics-linreg.nix) { });
 
-  scientific = self.callPackage (./pkgs/scientific.nix) { };
+  streaming = f final prev "streaming" (final.callPackage (./pkgs/streaming.nix) { });
 
-  scotty = self.callPackage (./pkgs/scotty.nix) { };
+  streaming-binary = f final prev "streaming-binary" (final.callPackage (./pkgs/streaming-binary.nix) { });
 
-  sdl2 = self.callPackage (./pkgs/sdl2.nix) { };
+  streaming-bytestring = f final prev "streaming-bytestring" (final.callPackage (./pkgs/streaming-bytestring.nix) { });
 
-  sdl2-gfx = self.callPackage (./pkgs/sdl2-gfx.nix) { };
+  streamly = f final prev "streamly" (final.callPackage (./pkgs/streamly.nix) { });
 
-  sdl2-image = self.callPackage (./pkgs/sdl2-image.nix) { };
+  streamly-core = f final prev "streamly-core" (final.callPackage (./pkgs/streamly-core.nix) { });
 
-  sdl2-mixer = self.callPackage (./pkgs/sdl2-mixer.nix) { };
+  strict-list = f final prev "strict-list" (final.callPackage (./pkgs/strict-list.nix) { });
 
-  sdl2-ttf = self.callPackage (./pkgs/sdl2-ttf.nix) { };
+  string-conv = f final prev "string-conv" (final.callPackage (./pkgs/string-conv.nix) { });
 
-  semialign = self.callPackage (./pkgs/semialign.nix) { };
+  stripeapi = f final prev "stripeapi" (final.callPackage (./pkgs/stripeapi.nix) { });
 
-  semigroupoids = self.callPackage (./pkgs/semigroupoids.nix) { };
+  sundown = f final prev "sundown" (final.callPackage (./pkgs/sundown.nix) { });
 
-  semigroups = self.callPackage (./pkgs/semigroups.nix) { };
+  tasty-hslua = f final prev "tasty-hslua" (final.callPackage (./pkgs/tasty-hslua.nix) { });
 
-  semirings = self.callPackage (./pkgs/semirings.nix) { };
+  tasty-lua = f final prev "tasty-lua" (final.callPackage (./pkgs/tasty-lua.nix) { });
 
-  serialise = self.callPackage (./pkgs/serialise.nix) { };
+  tasty-rerun = f final prev "tasty-rerun" (final.callPackage (./pkgs/tasty-rerun.nix) { });
 
-  servant = self.callPackage (./pkgs/servant.nix) { };
+  tdigest = f final prev "tdigest" (final.callPackage (./pkgs/tdigest.nix) { });
 
-  servant-blaze = self.callPackage (./pkgs/servant-blaze.nix) { };
+  template-haskell-compat-v0208 = f final prev "template-haskell-compat-v0208" (final.callPackage (./pkgs/template-haskell-compat-v0208.nix) { });
 
-  servant-client = self.callPackage (./pkgs/servant-client.nix) { };
+  test-framework-smallcheck = f final prev "test-framework-smallcheck" (final.callPackage (./pkgs/test-framework-smallcheck.nix) { });
 
-  servant-client-core = self.callPackage (./pkgs/servant-client-core.nix) { };
+  testing-feat = f final prev "testing-feat" (final.callPackage (./pkgs/testing-feat.nix) { });
 
-  servant-docs = self.callPackage (./pkgs/servant-docs.nix) { };
+  testing-type-modifiers = f final prev "testing-type-modifiers" (final.callPackage (./pkgs/testing-type-modifiers.nix) { });
 
-  servant-effectful = self.callPackage (./pkgs/servant-effectful.nix) { };
+  texmath = f final prev "texmath" (final.callPackage (./pkgs/texmath.nix) { });
 
-  servant-foreign = self.callPackage (./pkgs/servant-foreign.nix) { };
+  text-ansi = f final prev "text-ansi" (final.callPackage (./pkgs/text-ansi.nix) { });
 
-  servant-lucid = self.callPackage (./pkgs/servant-lucid.nix) { };
+  text-builder = f final prev "text-builder" (final.callPackage (./pkgs/text-builder.nix) { });
 
-  servant-multipart = self.callPackage (./pkgs/servant-multipart.nix) { };
+  text-builder-dev = f final prev "text-builder-dev" (final.callPackage (./pkgs/text-builder-dev.nix) { });
 
-  servant-multipart-api = self.callPackage (./pkgs/servant-multipart-api.nix) { };
+  text-builder-linear = f final prev "text-builder-linear" (final.callPackage (./pkgs/text-builder-linear.nix) { });
 
-  servant-polysemy = self.callPackage (./pkgs/servant-polysemy.nix) { };
+  text-display = f final prev "text-display" (final.callPackage (./pkgs/text-display.nix) { });
 
-  servant-server = self.callPackage (./pkgs/servant-server.nix) { };
+  text-icu = f final prev "text-icu" (final.callPackage (./pkgs/text-icu.nix) { });
 
-  servant-static-th = self.callPackage (./pkgs/servant-static-th.nix) { };
+  text-latin1 = f final prev "text-latin1" (final.callPackage (./pkgs/text-latin1.nix) { });
 
-  servant-swagger = self.callPackage (./pkgs/servant-swagger.nix) { };
+  text-printer = f final prev "text-printer" (final.callPackage (./pkgs/text-printer.nix) { });
 
-  servant-swagger-ui = self.callPackage (./pkgs/servant-swagger-ui.nix) { };
+  text-rope = f final prev "text-rope" (final.callPackage (./pkgs/text-rope.nix) { });
 
-  servant-swagger-ui-core = self.callPackage (./pkgs/servant-swagger-ui-core.nix) { };
+  th-desugar = f final prev "th-desugar" (final.callPackage (./pkgs/th-desugar.nix) { });
 
-  shake = self.callPackage (./pkgs/shake.nix) { };
+  these-skinny = f final prev "these-skinny" (final.callPackage (./pkgs/these-skinny.nix) { });
 
-  shakespeare = self.callPackage (./pkgs/shakespeare.nix) { };
+  thyme = f final prev "thyme" (final.callPackage (./pkgs/thyme.nix) { });
 
-  shelly = self.callPackage (./pkgs/shelly.nix) { };
+  tidal = f final prev "tidal" (final.callPackage (./pkgs/tidal.nix) { });
 
-  simple-sendfile = self.callPackage (./pkgs/simple-sendfile.nix) { };
+  tidal-link = f final prev "tidal-link" (final.callPackage (./pkgs/tidal-link.nix) { });
 
-  singleton-bool = self.callPackage (./pkgs/singleton-bool.nix) { };
+  time-units = f final prev "time-units" (final.callPackage (./pkgs/time-units.nix) { });
 
-  singletons = self.callPackage (./pkgs/singletons.nix) { };
+  timeit = f final prev "timeit" (final.callPackage (./pkgs/timeit.nix) { });
 
-  skylighting = self.callPackage (./pkgs/skylighting.nix) { };
+  timing-convenience = f final prev "timing-convenience" (final.callPackage (./pkgs/timing-convenience.nix) { });
 
-  skylighting-core = self.callPackage (./pkgs/skylighting-core.nix) { };
+  tmp-postgres = f final prev "tmp-postgres" (final.callPackage (./pkgs/tmp-postgres.nix) { });
 
-  skylighting-format-ansi = self.callPackage (./pkgs/skylighting-format-ansi.nix) { };
+  toml-parser = f final prev "toml-parser" (final.callPackage (./pkgs/toml-parser.nix) { });
 
-  skylighting-format-blaze-html = self.callPackage (./pkgs/skylighting-format-blaze-html.nix) { };
+  torsor = f final prev "torsor" (final.callPackage (./pkgs/torsor.nix) { });
 
-  skylighting-format-latex = self.callPackage (./pkgs/skylighting-format-latex.nix) { };
+  transformers-except = f final prev "transformers-except" (final.callPackage (./pkgs/transformers-except.nix) { });
 
-  slugify = self.callPackage (./pkgs/slugify.nix) { };
+  tuple = f final prev "tuple" (final.callPackage (./pkgs/tuple.nix) { });
 
-  socks = self.callPackage (./pkgs/socks.nix) { };
+  tuples = f final prev "tuples" (final.callPackage (./pkgs/tuples.nix) { });
 
-  some = self.callPackage (./pkgs/some.nix) { };
+  type-errors-pretty = f final prev "type-errors-pretty" (final.callPackage (./pkgs/type-errors-pretty.nix) { });
 
-  sop-core = self.callPackage (./pkgs/sop-core.nix) { };
+  type-hint = f final prev "type-hint" (final.callPackage (./pkgs/type-hint.nix) { });
 
-  souffle-haskell = self.callPackage (./pkgs/souffle-haskell.nix) { };
+  typed-process-effectful = f final prev "typed-process-effectful" (final.callPackage (./pkgs/typed-process-effectful.nix) { });
 
-  split = self.callPackage (./pkgs/split.nix) { };
+  typerep-map = f final prev "typerep-map" (final.callPackage (./pkgs/typerep-map.nix) { });
 
-  splitmix = self.callPackage (./pkgs/splitmix.nix) { };
+  typst = f final prev "typst" (final.callPackage (./pkgs/typst.nix) { });
 
-  sqlite-simple = self.callPackage (./pkgs/sqlite-simple.nix) { };
+  typst-symbols = f final prev "typst-symbols" (final.callPackage (./pkgs/typst-symbols.nix) { });
 
-  statistics = self.callPackage (./pkgs/statistics.nix) { };
+  uglymemo = f final prev "uglymemo" (final.callPackage (./pkgs/uglymemo.nix) { });
 
-  streaming-commons = self.callPackage (./pkgs/streaming-commons.nix) { };
+  unicode-collation = f final prev "unicode-collation" (final.callPackage (./pkgs/unicode-collation.nix) { });
 
-  strict = self.callPackage (./pkgs/strict.nix) { };
+  unicode-data = f final prev "unicode-data" (final.callPackage (./pkgs/unicode-data.nix) { });
 
-  string-interpolate = self.callPackage (./pkgs/string-interpolate.nix) { };
+  unicode-transforms = f final prev "unicode-transforms" (final.callPackage (./pkgs/unicode-transforms.nix) { });
 
-  string-qq = self.callPackage (./pkgs/string-qq.nix) { };
+  universe-reverse-instances = f final prev "universe-reverse-instances" (final.callPackage (./pkgs/universe-reverse-instances.nix) { });
 
-  swagger2 = self.callPackage (./pkgs/swagger2.nix) { };
+  unix-bytestring = f final prev "unix-bytestring" (final.callPackage (./pkgs/unix-bytestring.nix) { });
 
-  syb = self.callPackage (./pkgs/syb.nix) { };
+  unix-memory = f final prev "unix-memory" (final.callPackage (./pkgs/unix-memory.nix) { });
 
-  sydtest = self.callPackage (./pkgs/sydtest.nix) { };
+  unlifted = f final prev "unlifted" (final.callPackage (./pkgs/unlifted.nix) { });
 
-  sydtest-discover = self.callPackage (./pkgs/sydtest-discover.nix) { };
+  uri-bytestring-aeson = f final prev "uri-bytestring-aeson" (final.callPackage (./pkgs/uri-bytestring-aeson.nix) { });
 
-  tagged = self.callPackage (./pkgs/tagged.nix) { };
+  url-slug = f final prev "url-slug" (final.callPackage (./pkgs/url-slug.nix) { });
 
-  tar = self.callPackage (./pkgs/tar.nix) { };
+  validation = f final prev "validation" (final.callPackage (./pkgs/validation.nix) { });
 
-  tasty = self.callPackage (./pkgs/tasty.nix) { };
+  validity-case-insensitive = f final prev "validity-case-insensitive" (final.callPackage (./pkgs/validity-case-insensitive.nix) { });
 
-  tasty-bench = self.callPackage (./pkgs/tasty-bench.nix) { };
+  validity-network-uri = f final prev "validity-network-uri" (final.callPackage (./pkgs/validity-network-uri.nix) { });
 
-  tasty-discover = self.callPackage (./pkgs/tasty-discover.nix) { };
+  validity-path = f final prev "validity-path" (final.callPackage (./pkgs/validity-path.nix) { });
 
-  tasty-expected-failure = self.callPackage (./pkgs/tasty-expected-failure.nix) { };
+  validity-persistent = f final prev "validity-persistent" (final.callPackage (./pkgs/validity-persistent.nix) { });
 
-  tasty-golden = self.callPackage (./pkgs/tasty-golden.nix) { };
+  validity-primitive = f final prev "validity-primitive" (final.callPackage (./pkgs/validity-primitive.nix) { });
 
-  tasty-hedgehog = self.callPackage (./pkgs/tasty-hedgehog.nix) { };
+  validity-time = f final prev "validity-time" (final.callPackage (./pkgs/validity-time.nix) { });
 
-  tasty-hslua = self.callPackage (./pkgs/tasty-hslua.nix) { };
+  validity-uuid = f final prev "validity-uuid" (final.callPackage (./pkgs/validity-uuid.nix) { });
 
-  tasty-hunit = self.callPackage (./pkgs/tasty-hunit.nix) { };
+  vector-sized = f final prev "vector-sized" (final.callPackage (./pkgs/vector-sized.nix) { });
 
-  tasty-lua = self.callPackage (./pkgs/tasty-lua.nix) { };
+  wai-log = f final prev "wai-log" (final.callPackage (./pkgs/wai-log.nix) { });
 
-  tasty-quickcheck = self.callPackage (./pkgs/tasty-quickcheck.nix) { };
+  wai-middleware-heartbeat = f final prev "wai-middleware-heartbeat" (final.callPackage (./pkgs/wai-middleware-heartbeat.nix) { });
 
-  tasty-smallcheck = self.callPackage (./pkgs/tasty-smallcheck.nix) { };
+  wai-middleware-prometheus = f final prev "wai-middleware-prometheus" (final.callPackage (./pkgs/wai-middleware-prometheus.nix) { });
 
-  tasty-wai = self.callPackage (./pkgs/tasty-wai.nix) { };
+  wai-middleware-static = f final prev "wai-middleware-static" (final.callPackage (./pkgs/wai-middleware-static.nix) { });
 
-  temporary = self.callPackage (./pkgs/temporary.nix) { };
+  wai-websockets = f final prev "wai-websockets" (final.callPackage (./pkgs/wai-websockets.nix) { });
 
-  test-framework = self.callPackage (./pkgs/test-framework.nix) { };
+  websockets = f final prev "websockets" (final.callPackage (./pkgs/websockets.nix) { });
 
-  test-framework-hunit = self.callPackage (./pkgs/test-framework-hunit.nix) { };
+  wide-word = f final prev "wide-word" (final.callPackage (./pkgs/wide-word.nix) { });
 
-  test-framework-quickcheck2 = self.callPackage (./pkgs/test-framework-quickcheck2.nix) { };
+  wizards = f final prev "wizards" (final.callPackage (./pkgs/wizards.nix) { });
 
-  texmath = self.callPackage (./pkgs/texmath.nix) { };
+  wl-pprint-text = f final prev "wl-pprint-text" (final.callPackage (./pkgs/wl-pprint-text.nix) { });
 
-  text-display = self.callPackage (./pkgs/text-display.nix) { };
+  word-compat = f final prev "word-compat" (final.callPackage (./pkgs/word-compat.nix) { });
 
-  text-manipulate = self.callPackage (./pkgs/text-manipulate.nix) { };
+  wuss = f final prev "wuss" (final.callPackage (./pkgs/wuss.nix) { });
 
-  text-metrics = self.callPackage (./pkgs/text-metrics.nix) { };
+  xml-conduit-writer = f final prev "xml-conduit-writer" (final.callPackage (./pkgs/xml-conduit-writer.nix) { });
 
-  text-rope = self.callPackage (./pkgs/text-rope.nix) { };
-
-  text-short = self.callPackage (./pkgs/text-short.nix) { };
-
-  text-zipper = self.callPackage (./pkgs/text-zipper.nix) { };
-
-  tf-random = self.callPackage (./pkgs/tf-random.nix) { };
-
-  th-abstraction = self.callPackage (./pkgs/th-abstraction.nix) { };
-
-  th-env = self.callPackage (./pkgs/th-env.nix) { };
-
-  th-expand-syns = self.callPackage (./pkgs/th-expand-syns.nix) { };
-
-  th-extras = self.callPackage (./pkgs/th-extras.nix) { };
-
-  th-lift-instances = self.callPackage (./pkgs/th-lift-instances.nix) { };
-
-  th-orphans = self.callPackage (./pkgs/th-orphans.nix) { };
-
-  th-reify-many = self.callPackage (./pkgs/th-reify-many.nix) { };
-
-  these = self.callPackage (./pkgs/these.nix) { };
-
-  these-skinny = self.callPackage (./pkgs/these-skinny.nix) { };
-
-  tidal = self.callPackage (./pkgs/tidal.nix) { };
-
-  time-compat = self.callPackage (./pkgs/time-compat.nix) { };
-
-  time-effectful = self.callPackage (./pkgs/time-effectful.nix) { };
-
-  tls = self.callPackage (./pkgs/tls.nix) { };
-
-  tls-session-manager = self.callPackage (./pkgs/tls-session-manager.nix) { };
-
-  transformers-compat = self.callPackage (./pkgs/transformers-compat.nix) { };
-
-  tree-diff = self.callPackage (./pkgs/tree-diff.nix) { };
-
-  trifecta = self.callPackage (./pkgs/trifecta.nix) { };
-
-  type-equality = self.callPackage (./pkgs/type-equality.nix) { };
-
-  type-errors = self.callPackage (./pkgs/type-errors.nix) { };
-
-  type-errors-pretty = self.callPackage (./pkgs/type-errors-pretty.nix) { };
-
-  typed-process = self.callPackage (./pkgs/typed-process.nix) { };
-
-  typerep-map = self.callPackage (./pkgs/typerep-map.nix) { };
-
-  unagi-chan = self.callPackage (./pkgs/unagi-chan.nix) { };
-
-  unicode-collation = self.callPackage (./pkgs/unicode-collation.nix) { };
-
-  unicode-data = self.callPackage (./pkgs/unicode-data.nix) { };
-
-  unicode-transforms = self.callPackage (./pkgs/unicode-transforms.nix) { };
-
-  uniplate = self.callPackage (./pkgs/uniplate.nix) { };
-
-  universe-base = self.callPackage (./pkgs/universe-base.nix) { };
-
-  unliftio = self.callPackage (./pkgs/unliftio.nix) { };
-
-  unliftio-core = self.callPackage (./pkgs/unliftio-core.nix) { };
-
-  unordered-containers = self.callPackage (./pkgs/unordered-containers.nix) { };
-
-  uri-encode = self.callPackage (./pkgs/uri-encode.nix) { };
-
-  utf8-string = self.callPackage (./pkgs/utf8-string.nix) { };
-
-  uuid = self.callPackage (./pkgs/uuid.nix) { };
-
-  uuid-types = self.callPackage (./pkgs/uuid-types.nix) { };
-
-  validity = self.callPackage (./pkgs/validity.nix) { };
-
-  validity-aeson = self.callPackage (./pkgs/validity-aeson.nix) { };
-
-  validity-bytestring = self.callPackage (./pkgs/validity-bytestring.nix) { };
-
-  validity-case-insensitive = self.callPackage (./pkgs/validity-case-insensitive.nix) { };
-
-  validity-containers = self.callPackage (./pkgs/validity-containers.nix) { };
-
-  validity-path = self.callPackage (./pkgs/validity-path.nix) { };
-
-  validity-persistent = self.callPackage (./pkgs/validity-persistent.nix) { };
-
-  validity-primitive = self.callPackage (./pkgs/validity-primitive.nix) { };
-
-  validity-scientific = self.callPackage (./pkgs/validity-scientific.nix) { };
-
-  validity-text = self.callPackage (./pkgs/validity-text.nix) { };
-
-  validity-time = self.callPackage (./pkgs/validity-time.nix) { };
-
-  validity-unordered-containers = self.callPackage (./pkgs/validity-unordered-containers.nix) { };
-
-  validity-uuid = self.callPackage (./pkgs/validity-uuid.nix) { };
-
-  validity-vector = self.callPackage (./pkgs/validity-vector.nix) { };
-
-  vault = self.callPackage (./pkgs/vault.nix) { };
-
-  vec = self.callPackage (./pkgs/vec.nix) { };
-
-  vector = self.callPackage (./pkgs/vector.nix) { };
-
-  vector-algorithms = self.callPackage (./pkgs/vector-algorithms.nix) { };
-
-  vector-binary-instances = self.callPackage (./pkgs/vector-binary-instances.nix) { };
-
-  vector-instances = self.callPackage (./pkgs/vector-instances.nix) { };
-
-  vector-th-unbox = self.callPackage (./pkgs/vector-th-unbox.nix) { };
-
-  vinyl = self.callPackage (./pkgs/vinyl.nix) { };
-
-  void = self.callPackage (./pkgs/void.nix) { };
-
-  vty = self.callPackage (./pkgs/vty.nix) { };
-
-  wai = self.callPackage (./pkgs/wai.nix) { };
-
-  wai-app-static = self.callPackage (./pkgs/wai-app-static.nix) { };
-
-  wai-extra = self.callPackage (./pkgs/wai-extra.nix) { };
-
-  wai-logger = self.callPackage (./pkgs/wai-logger.nix) { };
-
-  wai-middleware-heartbeat = self.callPackage (./pkgs/wai-middleware-heartbeat.nix) { };
-
-  wai-middleware-static = self.callPackage (./pkgs/wai-middleware-static.nix) { };
-
-  warp = self.callPackage (./pkgs/warp.nix) { };
-
-  warp-tls = self.callPackage (./pkgs/warp-tls.nix) { };
-
-  websockets = self.callPackage (./pkgs/websockets.nix) { };
-
-  with-utf8 = self.callPackage (./pkgs/with-utf8.nix) { };
-
-  witherable = self.callPackage (./pkgs/witherable.nix) { };
-
-  word-wrap = self.callPackage (./pkgs/word-wrap.nix) { };
-
-  x509 = self.callPackage (./pkgs/x509.nix) { };
-
-  x509-store = self.callPackage (./pkgs/x509-store.nix) { };
-
-  x509-system = self.callPackage (./pkgs/x509-system.nix) { };
-
-  x509-validation = self.callPackage (./pkgs/x509-validation.nix) { };
-
-  xml-conduit = self.callPackage (./pkgs/xml-conduit.nix) { };
-
-  yaml = self.callPackage (./pkgs/yaml.nix) { };
+  zigzag = f final prev "zigzag" (final.callPackage (./pkgs/zigzag.nix) { });
 
 }

pkgs/BNFC.nix

+{ mkDerivation, HUnit, QuickCheck, alex, array, base, containers
+, deepseq, directory, filepath, happy, hspec, hspec-discover, lib
+, mtl, pretty, process, string-qq, temporary, time, transformers
+}:
+mkDerivation {
+  pname = "BNFC";
+  version = "2.9.5";
+  sha256 = "fa35e9a2a2bd12c3680482a350f57963807ccc9e964a206cb09e5b1a4d02576b";
+  isLibrary = true;
+  isExecutable = true;
+  enableSeparateDataOutput = false;
+  libraryHaskellDepends = [
+    array base containers deepseq directory filepath mtl pretty process
+    string-qq time transformers
+  ];
+  libraryToolDepends = [ alex happy ];
+  executableHaskellDepends = [ base ];
+  testHaskellDepends = [
+    array base containers deepseq directory filepath hspec HUnit mtl
+    pretty process QuickCheck string-qq temporary time
+  ];
+  testToolDepends = [ alex happy hspec-discover ];
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
+  jailbreak = true;
+  doCheck = false;
+  doBenchmark = false;
+  hyperlinkSource = false;
+  homepage = "https://bnfc.digitalgrammars.com/";
+  description = "A compiler front-end generator";
+  license = lib.licenses.bsd3;
+  broken = false;
+}
\ No newline at end of file

pkgs/Boolean.nix

+{ mkDerivation, base, lib }:
+mkDerivation {
+  pname = "Boolean";
+  version = "0.2.4";
+  sha256 = "67216013b02b8ac5b534a1ef25f409f930eea1a85eae801933a01ad43145eef8";
+  revision = "1";
+  editedCabalFile = "0q04fgnfgskwsmj3g25vfs39724wh1wjl6m6x08bi9fg9rxcf4rc";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
+  libraryHaskellDepends = [ base ];
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
+  jailbreak = true;
+  doCheck = false;
+  doBenchmark = false;
+  hyperlinkSource = false;
+  description = "Generalized booleans and numbers";
+  license = lib.licenses.bsd3;
+  broken = false;
+}
\ No newline at end of file

pkgs/Cabal-QuickCheck.nix

-{ mkDerivation
-, base
-, bytestring
-, Cabal
-, Cabal-syntax
-, fetchgit
-, lib
-, QuickCheck
-}:
-mkDerivation {
-  pname = "Cabal-QuickCheck";
-  version = "3.9.0.0";
-  src = fetchgit {
-    url = "https://gitlab.haskell.org/ghc/packages/Cabal";
-    sha256 = "13prqza1wk1gc0az8lizrm97w6rwxv5lzvy5a4gahpr2wsliqjfg";
-    rev = "e9fdb85427ad1ef11a25c8b1f2286614c86a65ff";
-    fetchSubmodules = true;
-  };
-  postUnpack = "sourceRoot+=/Cabal-QuickCheck/; echo source root reset to $sourceRoot";
-  isLibrary = true;
-  isExecutable = false;
-  enableSeparateDataOutput = false;
-  libraryHaskellDepends = [
-    base
-    bytestring
-    Cabal
-    Cabal-syntax
-    QuickCheck
-  ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  description = "QuickCheck instances for types in Cabal";
-  license = "unknown";
-  broken = false;
-}

pkgs/Cabal-described.nix

-{ mkDerivation
-, base
-, Cabal
-, Cabal-syntax
-, containers
-, fetchgit
-, lib
-, pretty
-, QuickCheck
-, rere
-, tasty
-, tasty-quickcheck
-, transformers
-}:
-mkDerivation {
-  pname = "Cabal-described";
-  version = "3.9.0.0";
-  src = fetchgit {
-    url = "https://gitlab.haskell.org/ghc/packages/Cabal";
-    sha256 = "13prqza1wk1gc0az8lizrm97w6rwxv5lzvy5a4gahpr2wsliqjfg";
-    rev = "e9fdb85427ad1ef11a25c8b1f2286614c86a65ff";
-    fetchSubmodules = true;
-  };
-  postUnpack = "sourceRoot+=/Cabal-described/; echo source root reset to $sourceRoot";
-  isLibrary = true;
-  isExecutable = false;
-  enableSeparateDataOutput = false;
-  libraryHaskellDepends = [
-    base
-    Cabal
-    Cabal-syntax
-    containers
-    pretty
-    QuickCheck
-    rere
-    tasty
-    tasty-quickcheck
-    transformers
-  ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  description = "Described functionality for types in Cabal";
-  license = "unknown";
-  broken = false;
-}

pkgs/Cabal-syntax.nix

-{ mkDerivation
-, array
-, base
-, binary
-, bytestring
-, containers
-, deepseq
-, directory
-, fetchgit
-, filepath
-, lib
-, mtl
-, parsec
-, pretty
-, text
-, time
-, transformers
-, unix
-}:
-mkDerivation {
-  pname = "Cabal-syntax";
-  version = "3.9.0.0";
-  src = fetchgit {
-    url = "https://gitlab.haskell.org/ghc/packages/Cabal";
-    sha256 = "13prqza1wk1gc0az8lizrm97w6rwxv5lzvy5a4gahpr2wsliqjfg";
-    rev = "e9fdb85427ad1ef11a25c8b1f2286614c86a65ff";
-    fetchSubmodules = true;
-  };
-  postUnpack = "sourceRoot+=/Cabal-syntax/; echo source root reset to $sourceRoot";
-  isLibrary = true;
-  isExecutable = false;
-  enableSeparateDataOutput = false;
-  libraryHaskellDepends = [
-    array
-    base
-    binary
-    bytestring
-    containers
-    deepseq
-    directory
-    filepath
-    mtl
-    parsec
-    pretty
-    text
-    time
-    transformers
-    unix
-  ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  homepage = "http://www.haskell.org/cabal/";
-  description = "A library for working with .cabal files";
-  license = lib.licenses.bsd3;
-  broken = false;
-}

pkgs/Cabal.nix

-{ mkDerivation
-, array
-, base
-, bytestring
-, Cabal-syntax
-, containers
-, deepseq
-, directory
-, filepath
-, lib
-, mtl
-, parsec
-, pretty
-, process
-, text
-, time
-, transformers
-, unix
-}:
-mkDerivation {
-  pname = "Cabal";
-  version = "3.8.1.0";
-  sha256 = "7464cbe6c2f3d7e5d0232023a1a7330621f8b24853cb259fc89a2af85b736608";
-  isLibrary = true;
-  isExecutable = false;
-  enableSeparateDataOutput = false;
-  setupHaskellDepends = [ mtl parsec ];
-  libraryHaskellDepends = [
-    array
-    base
-    bytestring
-    Cabal-syntax
-    containers
-    deepseq
-    directory
-    filepath
-    mtl
-    parsec
-    pretty
-    process
-    text
-    time
-    transformers
-    unix
-  ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  homepage = "http://www.haskell.org/cabal/";
-  description = "A framework for packaging Haskell software";
-  license = lib.licenses.bsd3;
-  broken = false;
-}

pkgs/Diff.nix → pkgs/Decimal.nix

-{ mkDerivation
-, array
-, base
-, directory
-, lib
-, pretty
-, process
-, QuickCheck
-, test-framework
-, test-framework-quickcheck2
+{ mkDerivation, HUnit, QuickCheck, base, deepseq, lib
+, test-framework, test-framework-hunit, test-framework-quickcheck2
 }:
 mkDerivation {
-  pname = "Diff";
-  version = "0.4.1";
-  sha256 = "fd5e4aaac7219bcbb14834fb8580ebe0aae905958d0ad74f5338ea290b372670";
+  pname = "Decimal";
+  version = "0.5.2";
+  sha256 = "a37a0220424e4bcb8cae1d38844c7027ee314449758d0d14ff3e2e0a5c8a87a7";
   isLibrary = true;
   isExecutable = false;
   enableSeparateDataOutput = false;
-  libraryHaskellDepends = [ array base pretty ];
+  libraryHaskellDepends = [ base deepseq ];
   testHaskellDepends = [
-    array
-    base
-    directory
-    pretty
-    process
-    QuickCheck
-    test-framework
+    base deepseq HUnit QuickCheck test-framework test-framework-hunit
     test-framework-quickcheck2
   ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
   hyperlinkSource = false;
-  description = "O(ND) diff algorithm in haskell";
+  homepage = "https://github.com/PaulJohnson/Haskell-Decimal";
+  description = "Decimal numbers with variable precision";
   license = lib.licenses.bsd3;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/HTTP.nix

-{ mkDerivation
-, array
-, base
-, bytestring
-, deepseq
-, httpd-shed
-, HUnit
-, lib
-, mtl
-, network
-, network-uri
-, parsec
-, pureMD5
-, split
-, test-framework
-, test-framework-hunit
-, time
-, transformers
-}:
-mkDerivation {
-  pname = "HTTP";
-  version = "4000.4.1";
-  sha256 = "df31d8efec775124dab856d7177ddcba31be9f9e0836ebdab03d94392f2dd453";
-  revision = "1";
-  editedCabalFile = "04y04vbxbnblpmqqmpl8km4bkcjaj96nbxkssdr1zgbhqisxay5q";
-  isLibrary = true;
-  isExecutable = false;
-  enableSeparateDataOutput = false;
-  libraryHaskellDepends = [
-    array
-    base
-    bytestring
-    mtl
-    network
-    network-uri
-    parsec
-    time
-    transformers
-  ];
-  testHaskellDepends = [
-    base
-    bytestring
-    deepseq
-    httpd-shed
-    HUnit
-    mtl
-    network
-    network-uri
-    pureMD5
-    split
-    test-framework
-    test-framework-hunit
-  ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  homepage = "https://github.com/haskell/HTTP";
-  description = "A library for client-side HTTP";
-  license = lib.licenses.bsd3;
-  broken = false;
-}

pkgs/Hclip.nix

+{ mkDerivation, base, lib, mtl, process, strict }:
+mkDerivation {
+  pname = "Hclip";
+  version = "3.0.0.4";
+  sha256 = "d8c80bd2d035571cd76ce4f69453e9fcef4096dbc8868eb4cfcd7eb74fe5f712";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
+  libraryHaskellDepends = [ base mtl process strict ];
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
+  jailbreak = true;
+  doCheck = false;
+  doBenchmark = false;
+  hyperlinkSource = false;
+  homepage = "https://github.com/jetho/Hclip";
+  description = "A small cross-platform library for reading and modifying the system clipboard";
+  license = lib.licenses.bsd3;
+  broken = false;
+}
\ No newline at end of file

pkgs/HsYAML.nix

+{ mkDerivation, QuickCheck, base, bytestring, containers, deepseq
+, lib, mtl, parsec, tasty, tasty-quickcheck, text, transformers
+}:
+mkDerivation {
+  pname = "HsYAML";
+  version = "0.2.1.4";
+  sha256 = "b580a9463c1192ea4687950f07f582268e55e2c51c1874dcdade5a8b83da1a26";
+  isLibrary = true;
+  isExecutable = true;
+  enableSeparateDataOutput = false;
+  libraryHaskellDepends = [
+    base bytestring containers deepseq mtl parsec text transformers
+  ];
+  testHaskellDepends = [
+    base bytestring containers mtl QuickCheck tasty tasty-quickcheck
+    text
+  ];
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
+  jailbreak = true;
+  doCheck = false;
+  doBenchmark = false;
+  hyperlinkSource = false;
+  homepage = "https://github.com/haskell-hvr/HsYAML";
+  description = "Pure Haskell YAML 1.2 processor";
+  license = lib.licenses.gpl2Only;
+  broken = false;
+}
\ No newline at end of file

pkgs/httpd-shed.nix → pkgs/MemoTrie.nix

-{ mkDerivation, base, lib, network, network-bsd, network-uri }:
+{ mkDerivation, base, lib, newtype-generics }:
 mkDerivation {
-  pname = "httpd-shed";
-  version = "0.4.1.1";
-  sha256 = "590fcfcb401923652bfcaf8c9a81b3bbbe83a4b1d16f7ccfecf7e47f6b6cafa5";
+  pname = "MemoTrie";
+  version = "0.6.11";
+  sha256 = "f7a6abf136eac1c6b370678e14e9519ed88c0c2adf75f06d6855b464db0c2420";
   isLibrary = true;
   isExecutable = true;
   enableSeparateDataOutput = false;
-  libraryHaskellDepends = [ base network network-bsd network-uri ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
+  libraryHaskellDepends = [ base newtype-generics ];
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
   hyperlinkSource = false;
-  description = "A simple web-server with an interact style API";
+  homepage = "https://github.com/conal/MemoTrie";
+  description = "Trie-based memo functions";
   license = lib.licenses.bsd3;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/random-shuffle.nix → pkgs/MonadPrompt.nix

-{ mkDerivation, base, lib, MonadRandom, random }:
+{ mkDerivation, base, lib, mtl }:
 mkDerivation {
-  pname = "random-shuffle";
-  version = "0.0.4";
-  sha256 = "52704411f040fd0bf2361dad162e35dc13caa6535b2e4908d3513c00a95d0615";
+  pname = "MonadPrompt";
+  version = "1.0.0.5";
+  sha256 = "b012cbbe83650f741c7b7f6eafcc89dec299b0ac74a758b6f3a8cdfc5d3bbeda";
   isLibrary = true;
   isExecutable = false;
   enableSeparateDataOutput = false;
-  libraryHaskellDepends = [ base MonadRandom random ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
+  libraryHaskellDepends = [ base mtl ];
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
   hyperlinkSource = false;
-  description = "Random shuffle implementation";
+  description = "MonadPrompt, implementation & examples";
   license = lib.licenses.bsd3;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/NumInstances.nix

+{ mkDerivation, base, lib }:
+mkDerivation {
+  pname = "NumInstances";
+  version = "1.4";
+  sha256 = "cbdb2a49346f59ceb5ab38592d7bc52e5205580d431d0ac6d852fd9880e59679";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
+  libraryHaskellDepends = [ base ];
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
+  jailbreak = true;
+  doCheck = false;
+  doBenchmark = false;
+  hyperlinkSource = false;
+  homepage = "https://github.com/conal/NumInstances";
+  description = "Instances of numeric classes for functions and tuples";
+  license = lib.licenses.bsd3;
+  broken = false;
+}
\ No newline at end of file

pkgs/OpenGLRaw.nix

-{ mkDerivation
-, base
-, bytestring
-, containers
-, fixed
-, half
-, lib
-, libGL
-, text
-, transformers
+{ mkDerivation, base, bytestring, containers, fixed, half, lib
+, libGL, text, transformers
 }:
 mkDerivation {
   pname = "OpenGLRaw";
   version = "3.3.4.1";
   sha256 = "121abdea149ac74514efb2c1c1c319466757242d1b72a8bdf99d49535f06d31e";
+  revision = "2";
+  editedCabalFile = "1wrkv4ll7iag0a1liw6jqffhqg2nbfpdg1sa9dy88n9jli1jmikd";
   isLibrary = true;
   isExecutable = false;
   enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base
-    bytestring
-    containers
-    fixed
-    half
-    text
-    transformers
+    base bytestring containers fixed half text transformers
   ];
   librarySystemDepends = [ libGL ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
@@ -37,4 +25,4 @@ mkDerivation {
   description = "A raw binding for the OpenGL graphics system";
   license = lib.licenses.bsd3;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/PyF.nix

-{ mkDerivation
-, base
-, bytestring
-, deepseq
-, filepath
-, ghc
-, ghc-boot
-, hspec
-, HUnit
-, lib
-, mtl
-, parsec
-, process
-, template-haskell
-, temporary
-, text
-, time
+{ mkDerivation, HUnit, base, bytestring, deepseq, filepath, ghc
+, hspec, lib, mtl, parsec, process, template-haskell, temporary
+, text, time
 }:
 mkDerivation {
   pname = "PyF";
-  version = "0.11.1.0";
-  sha256 = "8fd451ac23e5e63813c464e1a8ac98ba5c2fb11599441c80fe9ebc0186e61c1f";
+  version = "0.11.3.0";
+  sha256 = "9e595d33ad95f5ae73cfccd4c914220ac6eddeca68d6ecb24420563edc1d96db";
   isLibrary = true;
   isExecutable = false;
   enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base
-    bytestring
-    ghc
-    ghc-boot
-    mtl
-    parsec
-    template-haskell
-    text
-    time
+    base bytestring ghc mtl parsec template-haskell text time
   ];
   testHaskellDepends = [
-    base
-    bytestring
-    deepseq
-    filepath
-    hspec
-    HUnit
-    process
-    template-haskell
-    temporary
-    text
-    time
+    base bytestring deepseq filepath hspec HUnit process
+    template-haskell temporary text time
   ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
@@ -57,4 +26,4 @@ mkDerivation {
   description = "Quasiquotations for a python like interpolated string formatter";
   license = lib.licenses.bsd3;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/Stream.nix

+{ mkDerivation, QuickCheck, base, lazysmallcheck, lib }:
+mkDerivation {
+  pname = "Stream";
+  version = "0.4.7.2";
+  sha256 = "990be249b3ef1b0075563026d4d2c803b86e3cbf168965ba6f9f2b4227a007d1";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
+  libraryHaskellDepends = [ base lazysmallcheck QuickCheck ];
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
+  jailbreak = true;
+  doCheck = false;
+  doBenchmark = false;
+  hyperlinkSource = false;
+  description = "A library for manipulating infinite lists";
+  license = lib.licenses.bsd3;
+  broken = false;
+}
\ No newline at end of file

pkgs/generics-sop.nix → pkgs/Unique.nix

-{ mkDerivation
-, base
-, criterion
-, deepseq
-, ghc-prim
-, lib
-, sop-core
-, template-haskell
-, th-abstraction
+{ mkDerivation, QuickCheck, base, bytestring, containers, criterion
+, extra, hashable, hspec, lib, quickcheck-instances
+, unordered-containers
 }:
 mkDerivation {
-  pname = "generics-sop";
-  version = "0.5.1.2";
-  sha256 = "639d4140520d608a73a81186aca6db40fcb03ec8a818dbce79fcb0b39aa70b25";
+  pname = "Unique";
+  version = "0.4.7.9";
+  sha256 = "34e8247ef2769cae219ff05bed0c8269d680396c451c1d31aa6ad506abc5c191";
   revision = "1";
-  editedCabalFile = "1s8bx25yrjqy1cj9y1s1m8a8qlby9dxjzin16yymz7g39fqcqxz8";
+  editedCabalFile = "10s0npnfkh7naj49afmyrvnilikp6426fbhi49f97pxrgcmy4dvw";
   isLibrary = true;
   isExecutable = false;
   enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base
-    ghc-prim
-    sop-core
-    template-haskell
-    th-abstraction
+    base containers extra hashable unordered-containers
   ];
-  testHaskellDepends = [ base ];
+  testHaskellDepends = [ base containers hspec QuickCheck ];
   benchmarkHaskellDepends = [
-    base
-    criterion
-    deepseq
-    template-haskell
+    base bytestring criterion hashable QuickCheck quickcheck-instances
   ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
   hyperlinkSource = false;
-  description = "Generic Programming using True Sums of Products";
+  description = "It provides the functionality like unix \"uniq\" utility";
   license = lib.licenses.bsd3;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/asn1-types.nix → pkgs/X11-xft.nix

-{ mkDerivation, base, bytestring, hourglass, lib, memory }:
+{ mkDerivation, X11, base, lib, libXft, utf8-string }:
 mkDerivation {
-  pname = "asn1-types";
+  pname = "X11-xft";
   version = "0.3.4";
-  sha256 = "78ee92a251379298ca820fa53edbf4b33c539b9fcd887c86f520c30e3b4e21a8";
+  sha256 = "6200d2deabe9638bad4d1fed4399e3147254c2776a0fae71bf38ca423242a916";
   isLibrary = true;
   isExecutable = false;
   enableSeparateDataOutput = false;
-  libraryHaskellDepends = [ base bytestring hourglass memory ];
-  enableLibraryProfiling = false;
-  enableExecutableProfiling = false;
-  doHaddock = false;
+  libraryHaskellDepends = [ base utf8-string X11 ];
+  libraryPkgconfigDepends = [ libXft ];
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
   hyperlinkSource = false;
-  homepage = "http://github.com/vincenthz/hs-asn1";
-  description = "ASN.1 types";
+  description = "Bindings to the Xft and some Xrender parts";
   license = lib.licenses.bsd3;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/X11.nix

+{ mkDerivation, base, data-default-class, lib, libX11
+, libXScrnSaver, libXext, libXinerama, libXrandr, libXrender
+}:
+mkDerivation {
+  pname = "X11";
+  version = "1.10.3";
+  sha256 = "d84ad1b8f5cdb65a0de17f84d765ebbb7aeeab9608c3740804da28100616d242";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
+  libraryHaskellDepends = [ base data-default-class ];
+  librarySystemDepends = [
+    libX11 libXext libXinerama libXrandr libXrender libXScrnSaver
+  ];
+  enableLibraryProfiling = true;
+  enableExecutableProfiling = true;
+  doHaddock = true;
+  jailbreak = true;
+  doCheck = false;
+  doBenchmark = false;
+  hyperlinkSource = false;
+  homepage = "https://github.com/xmonad/X11";
+  description = "A binding to the X11 graphics library";
+  license = lib.licenses.bsd3;
+  broken = false;
+}
\ No newline at end of file