modifiers.nix

+{ pkgs, ... }:
+
+with pkgs.lib;
+
+_: prev: name: v: if hasAttr name prev then warn "${name} exists in parent set" v else v

overlay.nix

+/* This file is auto-generated by horizon-gen-nix. Do not edit. */
+{ pkgs, f ? (final: prev: n: v: v), ... }:
+
+final: prev: with pkgs.haskell.lib; {
+  BNFC = f final prev "BNFC" (final.callPackage (./pkgs/BNFC.nix) { });
+
+  Boolean = f final prev "Boolean" (final.callPackage (./pkgs/Boolean.nix) { });
+
+  Decimal = f final prev "Decimal" (final.callPackage (./pkgs/Decimal.nix) { });
+
+  Hclip = f final prev "Hclip" (final.callPackage (./pkgs/Hclip.nix) { });
+
+  HsYAML = f final prev "HsYAML" (final.callPackage (./pkgs/HsYAML.nix) { });
+
+  MemoTrie = f final prev "MemoTrie" (final.callPackage (./pkgs/MemoTrie.nix) { });
+
+  MonadPrompt = f final prev "MonadPrompt" (final.callPackage (./pkgs/MonadPrompt.nix) { });
+
+  NumInstances = f final prev "NumInstances" (final.callPackage (./pkgs/NumInstances.nix) { });
+
+  OpenGLRaw = f final prev "OpenGLRaw" (final.callPackage (./pkgs/OpenGLRaw.nix) { });
+
+  PyF = f final prev "PyF" (final.callPackage (./pkgs/PyF.nix) { });
+
+  Stream = f final prev "Stream" (final.callPackage (./pkgs/Stream.nix) { });
+
+  Unique = f final prev "Unique" (final.callPackage (./pkgs/Unique.nix) { });
+
+  X11 = f final prev "X11" (final.callPackage (./pkgs/X11.nix) { });
+
+  X11-xft = f final prev "X11-xft" (final.callPackage (./pkgs/X11-xft.nix) { });
+
+  abstract-deque-tests = f final prev "abstract-deque-tests" (final.callPackage (./pkgs/abstract-deque-tests.nix) { });
+
+  active = f final prev "active" (final.callPackage (./pkgs/active.nix) { });
+
+  aeson-qq = f final prev "aeson-qq" (final.callPackage (./pkgs/aeson-qq.nix) { });
+
+  aeson-yaml = f final prev "aeson-yaml" (final.callPackage (./pkgs/aeson-yaml.nix) { });
+
+  alex = f final prev "alex" (final.callPackage (./pkgs/alex.nix) { });
+
+  alsa-core = f final prev "alsa-core" (final.callPackage (./pkgs/alsa-core.nix) { });
+
+  alsa-mixer = f final prev "alsa-mixer" (final.callPackage (./pkgs/alsa-mixer.nix) { });
+
+  ap-normalize = f final prev "ap-normalize" (final.callPackage (./pkgs/ap-normalize.nix) { });
+
+  apecs = f final prev "apecs" (final.callPackage (./pkgs/apecs.nix) { });
+
+  async-timer = f final prev "async-timer" (final.callPackage (./pkgs/async-timer.nix) { });
+
+  attoparsec-binary = f final prev "attoparsec-binary" (final.callPackage (./pkgs/attoparsec-binary.nix) { });
+
+  autodocodec-servant-multipart = f final prev "autodocodec-servant-multipart" (final.callPackage (./pkgs/autodocodec-servant-multipart.nix) { });
+
+  autoexporter = f final prev "autoexporter" (final.callPackage (./pkgs/autoexporter.nix) { });
+
+  base-prelude = f final prev "base-prelude" (final.callPackage (./pkgs/base-prelude.nix) { });
+
+  base32 = f final prev "base32" (final.callPackage (./pkgs/base32.nix) { });
+
+  base58-bytestring = f final prev "base58-bytestring" (final.callPackage (./pkgs/base58-bytestring.nix) { });
+
+  base64-bytestring-type = f final prev "base64-bytestring-type" (final.callPackage (./pkgs/base64-bytestring-type.nix) { });
+
+  beam-core = f final prev "beam-core" (final.callPackage (./pkgs/beam-core.nix) { });
+
+  beam-migrate = f final prev "beam-migrate" (final.callPackage (./pkgs/beam-migrate.nix) { });
+
+  beam-postgres = f final prev "beam-postgres" (final.callPackage (./pkgs/beam-postgres.nix) { });
+
+  beam-sqlite = f final prev "beam-sqlite" (final.callPackage (./pkgs/beam-sqlite.nix) { });
+
+  bech32 = f final prev "bech32" (final.callPackage (./pkgs/bech32.nix) { });
+
+  bech32-th = f final prev "bech32-th" (final.callPackage (./pkgs/bech32-th.nix) { });
+
+  binary-parser = f final prev "binary-parser" (final.callPackage (./pkgs/binary-parser.nix) { });
+
+  blaze-svg = f final prev "blaze-svg" (final.callPackage (./pkgs/blaze-svg.nix) { });
+
+  blaze-textual = f final prev "blaze-textual" (final.callPackage (./pkgs/blaze-textual.nix) { });
+
+  breakpoint = f final prev "breakpoint" (final.callPackage (./pkgs/breakpoint.nix) { });
+
+  byte-order = f final prev "byte-order" (final.callPackage (./pkgs/byte-order.nix) { });
+
+  bytebuild = f final prev "bytebuild" (final.callPackage (./pkgs/bytebuild.nix) { });
+
+  byteslice = f final prev "byteslice" (final.callPackage (./pkgs/byteslice.nix) { });
+
+  bytesmith = f final prev "bytesmith" (final.callPackage (./pkgs/bytesmith.nix) { });
+
+  bytestring-strict-builder = f final prev "bytestring-strict-builder" (final.callPackage (./pkgs/bytestring-strict-builder.nix) { });
+
+  bytestring-tree-builder = f final prev "bytestring-tree-builder" (final.callPackage (./pkgs/bytestring-tree-builder.nix) { });
+
+  c2hs = f final prev "c2hs" (final.callPackage (./pkgs/c2hs.nix) { });
+
+  cabal-fmt = f final prev "cabal-fmt" (final.callPackage (./pkgs/cabal-fmt.nix) { });
+
+  cache = f final prev "cache" (final.callPackage (./pkgs/cache.nix) { });
+
+  canonical-json = f final prev "canonical-json" (final.callPackage (./pkgs/canonical-json.nix) { });
+
+  casing = f final prev "casing" (final.callPackage (./pkgs/casing.nix) { });
+
+  cassava-megaparsec = f final prev "cassava-megaparsec" (final.callPackage (./pkgs/cassava-megaparsec.nix) { });
+
+  cheapskate = f final prev "cheapskate" (final.callPackage (./pkgs/cheapskate.nix) { });
+
+  checkers = f final prev "checkers" (final.callPackage (./pkgs/checkers.nix) { });
+
+  chronos = f final prev "chronos" (final.callPackage (./pkgs/chronos.nix) { });
+
+  circle-packing = f final prev "circle-packing" (final.callPackage (./pkgs/circle-packing.nix) { });
+
+  citeproc = f final prev "citeproc" (final.callPackage (./pkgs/citeproc.nix) { });
+
+  cmark-gfm = f final prev "cmark-gfm" (final.callPackage (./pkgs/cmark-gfm.nix) { });
+
+  co-log-core = f final prev "co-log-core" (final.callPackage (./pkgs/co-log-core.nix) { });
+
+  co-log-polysemy = f final prev "co-log-polysemy" (final.callPackage (./pkgs/co-log-polysemy.nix) { });
+
+  colourista = f final prev "colourista" (final.callPackage (./pkgs/colourista.nix) { });
+
+  commonmark = f final prev "commonmark" (final.callPackage (./pkgs/commonmark.nix) { });
+
+  commonmark-extensions = f final prev "commonmark-extensions" (final.callPackage (./pkgs/commonmark-extensions.nix) { });
+
+  commonmark-pandoc = f final prev "commonmark-pandoc" (final.callPackage (./pkgs/commonmark-pandoc.nix) { });
+
+  commutative-semigroups = f final prev "commutative-semigroups" (final.callPackage (./pkgs/commutative-semigroups.nix) { });
+
+  compact = f final prev "compact" (final.callPackage (./pkgs/compact.nix) { });
+
+  compactable = f final prev "compactable" (final.callPackage (./pkgs/compactable.nix) { });
+
+  composite-cassava = f final prev "composite-cassava" (final.callPackage (./pkgs/composite-cassava.nix) { });
+
+  composite-dhall = f final prev "composite-dhall" (final.callPackage (./pkgs/composite-dhall.nix) { });
+
+  composite-lens-extra = f final prev "composite-lens-extra" (final.callPackage (./pkgs/composite-lens-extra.nix) { });
+
+  composite-tuple = f final prev "composite-tuple" (final.callPackage (./pkgs/composite-tuple.nix) { });
+
+  composition-prelude = f final prev "composition-prelude" (final.callPackage (./pkgs/composition-prelude.nix) { });
+
+  conduit-combinators = f final prev "conduit-combinators" (final.callPackage (./pkgs/conduit-combinators.nix) { });
+
+  conduit-parse = f final prev "conduit-parse" (final.callPackage (./pkgs/conduit-parse.nix) { });
+
+  conformance = f final prev "conformance" (final.callPackage (./pkgs/conformance.nix) { });
+
+  conformance-gen = f final prev "conformance-gen" (final.callPackage (./pkgs/conformance-gen.nix) { });
+
+  contiguous = f final prev "contiguous" (final.callPackage (./pkgs/contiguous.nix) { });
+
+  contravariant-extras = f final prev "contravariant-extras" (final.callPackage (./pkgs/contravariant-extras.nix) { });
+
+  control-monad-free = f final prev "control-monad-free" (final.callPackage (./pkgs/control-monad-free.nix) { });
+
+  cryptonite-conduit = f final prev "cryptonite-conduit" (final.callPackage (./pkgs/cryptonite-conduit.nix) { });
+
+  cursor = f final prev "cursor" (final.callPackage (./pkgs/cursor.nix) { });
+
+  cursor-brick = f final prev "cursor-brick" (final.callPackage (./pkgs/cursor-brick.nix) { });
+
+  cursor-dirforest = f final prev "cursor-dirforest" (final.callPackage (./pkgs/cursor-dirforest.nix) { });
+
+  cursor-dirforest-brick = f final prev "cursor-dirforest-brick" (final.callPackage (./pkgs/cursor-dirforest-brick.nix) { });
+
+  cursor-dirforest-gen = f final prev "cursor-dirforest-gen" (final.callPackage (./pkgs/cursor-dirforest-gen.nix) { });
+
+  cursor-fuzzy-time = f final prev "cursor-fuzzy-time" (final.callPackage (./pkgs/cursor-fuzzy-time.nix) { });
+
+  cursor-gen = f final prev "cursor-gen" (final.callPackage (./pkgs/cursor-gen.nix) { });
+
+  data-bword = f final prev "data-bword" (final.callPackage (./pkgs/data-bword.nix) { });
+
+  data-checked = f final prev "data-checked" (final.callPackage (./pkgs/data-checked.nix) { });
+
+  data-dword = f final prev "data-dword" (final.callPackage (./pkgs/data-dword.nix) { });
+
+  data-endian = f final prev "data-endian" (final.callPackage (./pkgs/data-endian.nix) { });
+
+  data-ordlist = f final prev "data-ordlist" (final.callPackage (./pkgs/data-ordlist.nix) { });
+
+  data-serializer = f final prev "data-serializer" (final.callPackage (./pkgs/data-serializer.nix) { });
+
+  data-sketches = f final prev "data-sketches" (final.callPackage (./pkgs/data-sketches.nix) { });
+
+  data-sketches-core = f final prev "data-sketches-core" (final.callPackage (./pkgs/data-sketches-core.nix) { });
+
+  data-textual = f final prev "data-textual" (final.callPackage (./pkgs/data-textual.nix) { });
+
+  dbus = f final prev "dbus" (final.callPackage (./pkgs/dbus.nix) { });
+
+  deferred-folds = f final prev "deferred-folds" (final.callPackage (./pkgs/deferred-folds.nix) { });
+
+  deque = f final prev "deque" (final.callPackage (./pkgs/deque.nix) { });
+
+  deriving-aeson = f final prev "deriving-aeson" (final.callPackage (./pkgs/deriving-aeson.nix) { });
+
+  dictionary-sharing = f final prev "dictionary-sharing" (final.callPackage (./pkgs/dictionary-sharing.nix) { });
+
+  dimensional = f final prev "dimensional" (final.callPackage (./pkgs/dimensional.nix) { });
+
+  direct-sqlite = f final prev "direct-sqlite" (final.callPackage (./pkgs/direct-sqlite.nix) { });
+
+  dirforest = f final prev "dirforest" (final.callPackage (./pkgs/dirforest.nix) { });
+
+  djot = f final prev "djot" (final.callPackage (./pkgs/djot.nix) { });
+
+  dns = f final prev "dns" (final.callPackage (./pkgs/dns.nix) { });
+
+  doclayout = f final prev "doclayout" (final.callPackage (./pkgs/doclayout.nix) { });
+
+  doctemplates = f final prev "doctemplates" (final.callPackage (./pkgs/doctemplates.nix) { });
+
+  doctest-discover = f final prev "doctest-discover" (final.callPackage (./pkgs/doctest-discover.nix) { });
+
+  dom-lt = f final prev "dom-lt" (final.callPackage (./pkgs/dom-lt.nix) { });
+
+  double-conversion = f final prev "double-conversion" (final.callPackage (./pkgs/double-conversion.nix) { });
+
+  dual-tree = f final prev "dual-tree" (final.callPackage (./pkgs/dual-tree.nix) { });
+
+  effectful = f final prev "effectful" (final.callPackage (./pkgs/effectful.nix) { });
+
+  effectful-cache = f final prev "effectful-cache" (final.callPackage (./pkgs/effectful-cache.nix) { });
+
+  effectful-core = f final prev "effectful-core" (final.callPackage (./pkgs/effectful-core.nix) { });
+
+  ekg = f final prev "ekg" (final.callPackage (./pkgs/ekg.nix) { });
+
+  ekg-core = f final prev "ekg-core" (final.callPackage (./pkgs/ekg-core.nix) { });
+
+  ekg-json = f final prev "ekg-json" (final.callPackage (./pkgs/ekg-json.nix) { });
+
+  ekg-statsd = f final prev "ekg-statsd" (final.callPackage (./pkgs/ekg-statsd.nix) { });
+
+  ekg-wai = f final prev "ekg-wai" (final.callPackage (./pkgs/ekg-wai.nix) { });
+
+  emojis = f final prev "emojis" (final.callPackage (./pkgs/emojis.nix) { });
+
+  enclosed-exceptions = f final prev "enclosed-exceptions" (final.callPackage (./pkgs/enclosed-exceptions.nix) { });
+
+  enummapset = f final prev "enummapset" (final.callPackage (./pkgs/enummapset.nix) { });
+
+  exact-combinatorics = f final prev "exact-combinatorics" (final.callPackage (./pkgs/exact-combinatorics.nix) { });
+
+  exact-pi = f final prev "exact-pi" (final.callPackage (./pkgs/exact-pi.nix) { });
+
+  expiring-cache-map = f final prev "expiring-cache-map" (final.callPackage (./pkgs/expiring-cache-map.nix) { });
+
+  extended-reals = f final prev "extended-reals" (final.callPackage (./pkgs/extended-reals.nix) { });
+
+  fast-math = f final prev "fast-math" (final.callPackage (./pkgs/fast-math.nix) { });
+
+  fcf-containers = f final prev "fcf-containers" (final.callPackage (./pkgs/fcf-containers.nix) { });
+
+  fgl = f final prev "fgl" (final.callPackage (./pkgs/fgl.nix) { });
+
+  fgl-arbitrary = f final prev "fgl-arbitrary" (final.callPackage (./pkgs/fgl-arbitrary.nix) { });
+
+  filelock = f final prev "filelock" (final.callPackage (./pkgs/filelock.nix) { });
+
+  filemanip = f final prev "filemanip" (final.callPackage (./pkgs/filemanip.nix) { });
+
+  filtrable = f final prev "filtrable" (final.callPackage (./pkgs/filtrable.nix) { });
+
+  finite-field = f final prev "finite-field" (final.callPackage (./pkgs/finite-field.nix) { });
+
+  finite-typelits = f final prev "finite-typelits" (final.callPackage (./pkgs/finite-typelits.nix) { });
+
+  fixed = f final prev "fixed" (final.callPackage (./pkgs/fixed.nix) { });
+
+  floatshow = f final prev "floatshow" (final.callPackage (./pkgs/floatshow.nix) { });
+
+  fmt = f final prev "fmt" (final.callPackage (./pkgs/fmt.nix) { });
+
+  focus = f final prev "focus" (final.callPackage (./pkgs/focus.nix) { });
+
+  force-layout = f final prev "force-layout" (final.callPackage (./pkgs/force-layout.nix) { });
+
+  foreign-store = f final prev "foreign-store" (final.callPackage (./pkgs/foreign-store.nix) { });
+
+  friendly-time = f final prev "friendly-time" (final.callPackage (./pkgs/friendly-time.nix) { });
+
+  fusion-plugin-types = f final prev "fusion-plugin-types" (final.callPackage (./pkgs/fusion-plugin-types.nix) { });
+
+  fuzzy = f final prev "fuzzy" (final.callPackage (./pkgs/fuzzy.nix) { });
+
+  fuzzy-time = f final prev "fuzzy-time" (final.callPackage (./pkgs/fuzzy-time.nix) { });
+
+  fuzzy-time-gen = f final prev "fuzzy-time-gen" (final.callPackage (./pkgs/fuzzy-time-gen.nix) { });
+
+  generic-arbitrary = f final prev "generic-arbitrary" (final.callPackage (./pkgs/generic-arbitrary.nix) { });
+
+  generic-data = f final prev "generic-data" (final.callPackage (./pkgs/generic-data.nix) { });
+
+  generic-lens = f final prev "generic-lens" (final.callPackage (./pkgs/generic-lens.nix) { });
+
+  generic-lens-core = f final prev "generic-lens-core" (final.callPackage (./pkgs/generic-lens-core.nix) { });
+
+  generic-lens-lite = f final prev "generic-lens-lite" (final.callPackage (./pkgs/generic-lens-lite.nix) { });
+
+  generic-optics = f final prev "generic-optics" (final.callPackage (./pkgs/generic-optics.nix) { });
+
+  generic-optics-lite = f final prev "generic-optics-lite" (final.callPackage (./pkgs/generic-optics-lite.nix) { });
+
+  genvalidity-aeson = f final prev "genvalidity-aeson" (final.callPackage (./pkgs/genvalidity-aeson.nix) { });
+
+  genvalidity-bytestring = f final prev "genvalidity-bytestring" (final.callPackage (./pkgs/genvalidity-bytestring.nix) { });
+
+  genvalidity-case-insensitive = f final prev "genvalidity-case-insensitive" (final.callPackage (./pkgs/genvalidity-case-insensitive.nix) { });
+
+  genvalidity-containers = f final prev "genvalidity-containers" (final.callPackage (./pkgs/genvalidity-containers.nix) { });
+
+  genvalidity-criterion = f final prev "genvalidity-criterion" (final.callPackage (./pkgs/genvalidity-criterion.nix) { });
+
+  genvalidity-dirforest = f final prev "genvalidity-dirforest" (final.callPackage (./pkgs/genvalidity-dirforest.nix) { });
+
+  genvalidity-hspec-aeson = f final prev "genvalidity-hspec-aeson" (final.callPackage (./pkgs/genvalidity-hspec-aeson.nix) { });
+
+  genvalidity-hspec-optics = f final prev "genvalidity-hspec-optics" (final.callPackage (./pkgs/genvalidity-hspec-optics.nix) { });
+
+  genvalidity-network-uri = f final prev "genvalidity-network-uri" (final.callPackage (./pkgs/genvalidity-network-uri.nix) { });
+
+  genvalidity-path = f final prev "genvalidity-path" (final.callPackage (./pkgs/genvalidity-path.nix) { });
+
+  genvalidity-persistent = f final prev "genvalidity-persistent" (final.callPackage (./pkgs/genvalidity-persistent.nix) { });
+
+  genvalidity-scientific = f final prev "genvalidity-scientific" (final.callPackage (./pkgs/genvalidity-scientific.nix) { });
+
+  genvalidity-sydtest = f final prev "genvalidity-sydtest" (final.callPackage (./pkgs/genvalidity-sydtest.nix) { });
+
+  genvalidity-sydtest-aeson = f final prev "genvalidity-sydtest-aeson" (final.callPackage (./pkgs/genvalidity-sydtest-aeson.nix) { });
+
+  genvalidity-sydtest-hashable = f final prev "genvalidity-sydtest-hashable" (final.callPackage (./pkgs/genvalidity-sydtest-hashable.nix) { });
+
+  genvalidity-sydtest-lens = f final prev "genvalidity-sydtest-lens" (final.callPackage (./pkgs/genvalidity-sydtest-lens.nix) { });
+
+  genvalidity-sydtest-persistent = f final prev "genvalidity-sydtest-persistent" (final.callPackage (./pkgs/genvalidity-sydtest-persistent.nix) { });
+
+  genvalidity-text = f final prev "genvalidity-text" (final.callPackage (./pkgs/genvalidity-text.nix) { });
+
+  genvalidity-time = f final prev "genvalidity-time" (final.callPackage (./pkgs/genvalidity-time.nix) { });
+
+  genvalidity-unordered-containers = f final prev "genvalidity-unordered-containers" (final.callPackage (./pkgs/genvalidity-unordered-containers.nix) { });
+
+  genvalidity-uuid = f final prev "genvalidity-uuid" (final.callPackage (./pkgs/genvalidity-uuid.nix) { });
+
+  genvalidity-vector = f final prev "genvalidity-vector" (final.callPackage (./pkgs/genvalidity-vector.nix) { });
+
+  ghc-trace-events = f final prev "ghc-trace-events" (final.callPackage (./pkgs/ghc-trace-events.nix) { });
+
+  ghc-typelits-knownnat = f final prev "ghc-typelits-knownnat" (final.callPackage (./pkgs/ghc-typelits-knownnat.nix) { });
+
+  ghc-typelits-natnormalise = f final prev "ghc-typelits-natnormalise" (final.callPackage (./pkgs/ghc-typelits-natnormalise.nix) { });
+
+  githash = f final prev "githash" (final.callPackage (./pkgs/githash.nix) { });
+
+  graphviz = f final prev "graphviz" (final.callPackage (./pkgs/graphviz.nix) { });
+
+  gridtables = f final prev "gridtables" (final.callPackage (./pkgs/gridtables.nix) { });
+
+  haddock-library = f final prev "haddock-library" (final.callPackage (./pkgs/haddock-library.nix) { });
+
+  hasql = f final prev "hasql" (final.callPackage (./pkgs/hasql.nix) { });
+
+  hasql-explain-tests = f final prev "hasql-explain-tests" (final.callPackage (./pkgs/hasql-explain-tests.nix) { });
+
+  hasql-migration = f final prev "hasql-migration" (final.callPackage (./pkgs/hasql-migration.nix) { });
+
+  hasql-th = f final prev "hasql-th" (final.callPackage (./pkgs/hasql-th.nix) { });
+
+  hasql-transaction = f final prev "hasql-transaction" (final.callPackage (./pkgs/hasql-transaction.nix) { });
+
+  hdaemonize = f final prev "hdaemonize" (final.callPackage (./pkgs/hdaemonize.nix) { });
+
+  headed-megaparsec = f final prev "headed-megaparsec" (final.callPackage (./pkgs/headed-megaparsec.nix) { });
+
+  hedgehog-fn = f final prev "hedgehog-fn" (final.callPackage (./pkgs/hedgehog-fn.nix) { });
+
+  hedgehog-golden = f final prev "hedgehog-golden" (final.callPackage (./pkgs/hedgehog-golden.nix) { });
+
+  hedgehog-quickcheck = f final prev "hedgehog-quickcheck" (final.callPackage (./pkgs/hedgehog-quickcheck.nix) { });
+
+  heredoc = f final prev "heredoc" (final.callPackage (./pkgs/heredoc.nix) { });
+
+  hex-text = f final prev "hex-text" (final.callPackage (./pkgs/hex-text.nix) { });
+
+  hoauth2 = f final prev "hoauth2" (final.callPackage (./pkgs/hoauth2.nix) { });
+
+  hoauth2-providers = f final prev "hoauth2-providers" (final.callPackage (./pkgs/hoauth2-providers.nix) { });
+
+  hosc = f final prev "hosc" (final.callPackage (./pkgs/hosc.nix) { });
+
+  hslogger = f final prev "hslogger" (final.callPackage (./pkgs/hslogger.nix) { });
+
+  hslua = f final prev "hslua" (final.callPackage (./pkgs/hslua.nix) { });
+
+  hslua-aeson = f final prev "hslua-aeson" (final.callPackage (./pkgs/hslua-aeson.nix) { });
+
+  hslua-classes = f final prev "hslua-classes" (final.callPackage (./pkgs/hslua-classes.nix) { });
+
+  hslua-core = f final prev "hslua-core" (final.callPackage (./pkgs/hslua-core.nix) { });
+
+  hslua-list = f final prev "hslua-list" (final.callPackage (./pkgs/hslua-list.nix) { });
+
+  hslua-marshalling = f final prev "hslua-marshalling" (final.callPackage (./pkgs/hslua-marshalling.nix) { });
+
+  hslua-module-doclayout = f final prev "hslua-module-doclayout" (final.callPackage (./pkgs/hslua-module-doclayout.nix) { });
+
+  hslua-module-path = f final prev "hslua-module-path" (final.callPackage (./pkgs/hslua-module-path.nix) { });
+
+  hslua-module-system = f final prev "hslua-module-system" (final.callPackage (./pkgs/hslua-module-system.nix) { });
+
+  hslua-module-text = f final prev "hslua-module-text" (final.callPackage (./pkgs/hslua-module-text.nix) { });
+
+  hslua-module-version = f final prev "hslua-module-version" (final.callPackage (./pkgs/hslua-module-version.nix) { });
+
+  hslua-objectorientation = f final prev "hslua-objectorientation" (final.callPackage (./pkgs/hslua-objectorientation.nix) { });
+
+  hslua-packaging = f final prev "hslua-packaging" (final.callPackage (./pkgs/hslua-packaging.nix) { });
+
+  hslua-typing = f final prev "hslua-typing" (final.callPackage (./pkgs/hslua-typing.nix) { });
+
+  hspec-attoparsec = f final prev "hspec-attoparsec" (final.callPackage (./pkgs/hspec-attoparsec.nix) { });
+
+  hspec-contrib = f final prev "hspec-contrib" (final.callPackage (./pkgs/hspec-contrib.nix) { });
+
+  hspec-golden = f final prev "hspec-golden" (final.callPackage (./pkgs/hspec-golden.nix) { });
+
+  hspec-golden-aeson = f final prev "hspec-golden-aeson" (final.callPackage (./pkgs/hspec-golden-aeson.nix) { });
+
+  hsyslog = f final prev "hsyslog" (final.callPackage (./pkgs/hsyslog.nix) { });
+
+  html = f final prev "html" (final.callPackage (./pkgs/html.nix) { });
+
+  hw-fingertree = f final prev "hw-fingertree" (final.callPackage (./pkgs/hw-fingertree.nix) { });
+
+  hw-hedgehog = f final prev "hw-hedgehog" (final.callPackage (./pkgs/hw-hedgehog.nix) { });
+
+  hw-hspec-hedgehog = f final prev "hw-hspec-hedgehog" (final.callPackage (./pkgs/hw-hspec-hedgehog.nix) { });
+
+  hw-prim = f final prev "hw-prim" (final.callPackage (./pkgs/hw-prim.nix) { });
+
+  ical = f final prev "ical" (final.callPackage (./pkgs/ical.nix) { });
+
+  ical-gen = f final prev "ical-gen" (final.callPackage (./pkgs/ical-gen.nix) { });
+
+  ical-interop-test = f final prev "ical-interop-test" (final.callPackage (./pkgs/ical-interop-test.nix) { });
+
+  ical-recurrence = f final prev "ical-recurrence" (final.callPackage (./pkgs/ical-recurrence.nix) { });
+
+  ical-recurrence-gen = f final prev "ical-recurrence-gen" (final.callPackage (./pkgs/ical-recurrence-gen.nix) { });
+
+  indexed-list-literals = f final prev "indexed-list-literals" (final.callPackage (./pkgs/indexed-list-literals.nix) { });
+
+  inline-c = f final prev "inline-c" (final.callPackage (./pkgs/inline-c.nix) { });
+
+  int-cast = f final prev "int-cast" (final.callPackage (./pkgs/int-cast.nix) { });
+
+  integration = f final prev "integration" (final.callPackage (./pkgs/integration.nix) { });
+
+  intervals = f final prev "intervals" (final.callPackage (./pkgs/intervals.nix) { });
+
+  ipynb = f final prev "ipynb" (final.callPackage (./pkgs/ipynb.nix) { });
+
+  iso8601-time = f final prev "iso8601-time" (final.callPackage (./pkgs/iso8601-time.nix) { });
+
+  isomorphism-class = f final prev "isomorphism-class" (final.callPackage (./pkgs/isomorphism-class.nix) { });
+
+  iwlib = f final prev "iwlib" (final.callPackage (./pkgs/iwlib.nix) { });
+
+  jira-wiki-markup = f final prev "jira-wiki-markup" (final.callPackage (./pkgs/jira-wiki-markup.nix) { });
+
+  katip = f final prev "katip" (final.callPackage (./pkgs/katip.nix) { });
+
+  language-c = f final prev "language-c" (final.callPackage (./pkgs/language-c.nix) { });
+
+  lazy-search = f final prev "lazy-search" (final.callPackage (./pkgs/lazy-search.nix) { });
+
+  lazysmallcheck = f final prev "lazysmallcheck" (final.callPackage (./pkgs/lazysmallcheck.nix) { });
+
+  libsodium-bindings = f final prev "libsodium-bindings" (final.callPackage (./pkgs/libsodium-bindings.nix) { });
+
+  libsystemd-journal = f final prev "libsystemd-journal" (final.callPackage (./pkgs/libsystemd-journal.nix) { });
+
+  linear-base = f final prev "linear-base" (final.callPackage (./pkgs/linear-base.nix) { });
+
+  linear-generics = f final prev "linear-generics" (final.callPackage (./pkgs/linear-generics.nix) { });
+
+  list-transformer = f final prev "list-transformer" (final.callPackage (./pkgs/list-transformer.nix) { });
+
+  lockfree-queue = f final prev "lockfree-queue" (final.callPackage (./pkgs/lockfree-queue.nix) { });
+
+  log-base = f final prev "log-base" (final.callPackage (./pkgs/log-base.nix) { });
+
+  log-effectful = f final prev "log-effectful" (final.callPackage (./pkgs/log-effectful.nix) { });
+
+  loop = f final prev "loop" (final.callPackage (./pkgs/loop.nix) { });
+
+  lpeg = f final prev "lpeg" (final.callPackage (./pkgs/lpeg.nix) { });
+
+  lrucache = f final prev "lrucache" (final.callPackage (./pkgs/lrucache.nix) { });
+
+  lua = f final prev "lua" (final.callPackage (./pkgs/lua.nix) { });
+
+  lua-arbitrary = f final prev "lua-arbitrary" (final.callPackage (./pkgs/lua-arbitrary.nix) { });
+
+  lucid-alpine = f final prev "lucid-alpine" (final.callPackage (./pkgs/lucid-alpine.nix) { });
+
+  lucid-aria = f final prev "lucid-aria" (final.callPackage (./pkgs/lucid-aria.nix) { });
+
+  lucid-svg = f final prev "lucid-svg" (final.callPackage (./pkgs/lucid-svg.nix) { });
+
+  lvar = f final prev "lvar" (final.callPackage (./pkgs/lvar.nix) { });
+
+  markdown = f final prev "markdown" (final.callPackage (./pkgs/markdown.nix) { });
+
+  markov-chain-usage-model = f final prev "markov-chain-usage-model" (final.callPackage (./pkgs/markov-chain-usage-model.nix) { });
+
+  matrices = f final prev "matrices" (final.callPackage (./pkgs/matrices.nix) { });
+
+  matrix = f final prev "matrix" (final.callPackage (./pkgs/matrix.nix) { });
+
+  mersenne-random-pure64 = f final prev "mersenne-random-pure64" (final.callPackage (./pkgs/mersenne-random-pure64.nix) { });
+
+  mfsolve = f final prev "mfsolve" (final.callPackage (./pkgs/mfsolve.nix) { });
+
+  microbench = f final prev "microbench" (final.callPackage (./pkgs/microbench.nix) { });
+
+  microlens-aeson = f final prev "microlens-aeson" (final.callPackage (./pkgs/microlens-aeson.nix) { });
+
+  microlens-ghc = f final prev "microlens-ghc" (final.callPackage (./pkgs/microlens-ghc.nix) { });
+
+  microlens-platform = f final prev "microlens-platform" (final.callPackage (./pkgs/microlens-platform.nix) { });
+
+  microspec = f final prev "microspec" (final.callPackage (./pkgs/microspec.nix) { });
+
+  mime-mail = f final prev "mime-mail" (final.callPackage (./pkgs/mime-mail.nix) { });
+
+  mod = f final prev "mod" (final.callPackage (./pkgs/mod.nix) { });
+
+  monad-time-effectful = f final prev "monad-time-effectful" (final.callPackage (./pkgs/monad-time-effectful.nix) { });
+
+  monoid-extras = f final prev "monoid-extras" (final.callPackage (./pkgs/monoid-extras.nix) { });
+
+  monoid-subclasses = f final prev "monoid-subclasses" (final.callPackage (./pkgs/monoid-subclasses.nix) { });
+
+  mtl-prelude = f final prev "mtl-prelude" (final.callPackage (./pkgs/mtl-prelude.nix) { });
+
+  multiset = f final prev "multiset" (final.callPackage (./pkgs/multiset.nix) { });
+
+  natural-arithmetic = f final prev "natural-arithmetic" (final.callPackage (./pkgs/natural-arithmetic.nix) { });
+
+  natural-transformation = f final prev "natural-transformation" (final.callPackage (./pkgs/natural-transformation.nix) { });
+
+  network-conduit-tls = f final prev "network-conduit-tls" (final.callPackage (./pkgs/network-conduit-tls.nix) { });
+
+  network-ip = f final prev "network-ip" (final.callPackage (./pkgs/network-ip.nix) { });
+
+  newtype-generics = f final prev "newtype-generics" (final.callPackage (./pkgs/newtype-generics.nix) { });
+
+  non-negative = f final prev "non-negative" (final.callPackage (./pkgs/non-negative.nix) { });
+
+  nonempty-vector = f final prev "nonempty-vector" (final.callPackage (./pkgs/nonempty-vector.nix) { });
+
+  numeric-extras = f final prev "numeric-extras" (final.callPackage (./pkgs/numeric-extras.nix) { });
+
+  numeric-prelude = f final prev "numeric-prelude" (final.callPackage (./pkgs/numeric-prelude.nix) { });
+
+  numtype-dk = f final prev "numtype-dk" (final.callPackage (./pkgs/numtype-dk.nix) { });
+
+  odd-jobs = f final prev "odd-jobs" (final.callPackage (./pkgs/odd-jobs.nix) { });
+
+  one-liner = f final prev "one-liner" (final.callPackage (./pkgs/one-liner.nix) { });
+
+  one-time-password = f final prev "one-time-password" (final.callPackage (./pkgs/one-time-password.nix) { });
+
+  opentelemetry = f final prev "opentelemetry" (final.callPackage (./pkgs/opentelemetry.nix) { });
+
+  operational = f final prev "operational" (final.callPackage (./pkgs/operational.nix) { });
+
+  optparse-generic = f final prev "optparse-generic" (final.callPackage (./pkgs/optparse-generic.nix) { });
+
+  optparse-simple = f final prev "optparse-simple" (final.callPackage (./pkgs/optparse-simple.nix) { });
+
+  ordered-containers = f final prev "ordered-containers" (final.callPackage (./pkgs/ordered-containers.nix) { });
+
+  pager = f final prev "pager" (final.callPackage (./pkgs/pager.nix) { });
+
+  pandoc-lua-marshal = f final prev "pandoc-lua-marshal" (final.callPackage (./pkgs/pandoc-lua-marshal.nix) { });
+
+  pandoc-types = f final prev "pandoc-types" (final.callPackage (./pkgs/pandoc-types.nix) { });
+
+  parsec-numbers = f final prev "parsec-numbers" (final.callPackage (./pkgs/parsec-numbers.nix) { });
+
+  parsec1 = f final prev "parsec1" (final.callPackage (./pkgs/parsec1.nix) { });
+
+  parsers-megaparsec = f final prev "parsers-megaparsec" (final.callPackage (./pkgs/parsers-megaparsec.nix) { });
+
+  partial-order = f final prev "partial-order" (final.callPackage (./pkgs/partial-order.nix) { });
+
+  password = f final prev "password" (final.callPackage (./pkgs/password.nix) { });
+
+  password-types = f final prev "password-types" (final.callPackage (./pkgs/password-types.nix) { });
+
+  pcre-heavy = f final prev "pcre-heavy" (final.callPackage (./pkgs/pcre-heavy.nix) { });
+
+  pcre2 = f final prev "pcre2" (final.callPackage (./pkgs/pcre2.nix) { });
+
+  pg-entity = f final prev "pg-entity" (final.callPackage (./pkgs/pg-entity.nix) { });
+
+  pg-transact = f final prev "pg-transact" (final.callPackage (./pkgs/pg-transact.nix) { });
+
+  pg-transact-effectful = f final prev "pg-transact-effectful" (final.callPackage (./pkgs/pg-transact-effectful.nix) { });
+
+  pipes-safe = f final prev "pipes-safe" (final.callPackage (./pkgs/pipes-safe.nix) { });
+
+  polysemy-extra = f final prev "polysemy-extra" (final.callPackage (./pkgs/polysemy-extra.nix) { });
+
+  polysemy-kvstore = f final prev "polysemy-kvstore" (final.callPackage (./pkgs/polysemy-kvstore.nix) { });
+
+  polysemy-methodology = f final prev "polysemy-methodology" (final.callPackage (./pkgs/polysemy-methodology.nix) { });
+
+  polysemy-path = f final prev "polysemy-path" (final.callPackage (./pkgs/polysemy-path.nix) { });
+
+  polysemy-several = f final prev "polysemy-several" (final.callPackage (./pkgs/polysemy-several.nix) { });
+
+  polysemy-vinyl = f final prev "polysemy-vinyl" (final.callPackage (./pkgs/polysemy-vinyl.nix) { });
+
+  polysemy-zoo = f final prev "polysemy-zoo" (final.callPackage (./pkgs/polysemy-zoo.nix) { });
+
+  poolboy = f final prev "poolboy" (final.callPackage (./pkgs/poolboy.nix) { });
+
+  postgresql-binary = f final prev "postgresql-binary" (final.callPackage (./pkgs/postgresql-binary.nix) { });
+
+  postgresql-migration = f final prev "postgresql-migration" (final.callPackage (./pkgs/postgresql-migration.nix) { });
+
+  postgresql-simple-migration = f final prev "postgresql-simple-migration" (final.callPackage (./pkgs/postgresql-simple-migration.nix) { });
+
+  postgresql-syntax = f final prev "postgresql-syntax" (final.callPackage (./pkgs/postgresql-syntax.nix) { });
+
+  pqueue = f final prev "pqueue" (final.callPackage (./pkgs/pqueue.nix) { });
+
+  pretty-relative-time = f final prev "pretty-relative-time" (final.callPackage (./pkgs/pretty-relative-time.nix) { });
+
+  primes = f final prev "primes" (final.callPackage (./pkgs/primes.nix) { });
+
+  primitive-offset = f final prev "primitive-offset" (final.callPackage (./pkgs/primitive-offset.nix) { });
+
+  primitive-unaligned = f final prev "primitive-unaligned" (final.callPackage (./pkgs/primitive-unaligned.nix) { });
+
+  primitive-unlifted = f final prev "primitive-unlifted" (final.callPackage (./pkgs/primitive-unlifted.nix) { });
+
+  prometheus-client = f final prev "prometheus-client" (final.callPackage (./pkgs/prometheus-client.nix) { });
+
+  prometheus-metrics-ghc = f final prev "prometheus-metrics-ghc" (final.callPackage (./pkgs/prometheus-metrics-ghc.nix) { });
+
+  prometheus-proc = f final prev "prometheus-proc" (final.callPackage (./pkgs/prometheus-proc.nix) { });
+
+  proteaaudio-sdl = f final prev "proteaaudio-sdl" (final.callPackage (./pkgs/proteaaudio-sdl.nix) { });
+
+  qrcode-core = f final prev "qrcode-core" (final.callPackage (./pkgs/qrcode-core.nix) { });
+
+  qrcode-juicypixels = f final prev "qrcode-juicypixels" (final.callPackage (./pkgs/qrcode-juicypixels.nix) { });
+
+  quickcheck-arbitrary-adt = f final prev "quickcheck-arbitrary-adt" (final.callPackage (./pkgs/quickcheck-arbitrary-adt.nix) { });
+
+  quickcheck-assertions = f final prev "quickcheck-assertions" (final.callPackage (./pkgs/quickcheck-assertions.nix) { });
+
+  quote-quot = f final prev "quote-quot" (final.callPackage (./pkgs/quote-quot.nix) { });
+
+  random-fu = f final prev "random-fu" (final.callPackage (./pkgs/random-fu.nix) { });
+
+  raven-haskell = f final prev "raven-haskell" (final.callPackage (./pkgs/raven-haskell.nix) { });
+
+  refact = f final prev "refact" (final.callPackage (./pkgs/refact.nix) { });
+
+  refined = f final prev "refined" (final.callPackage (./pkgs/refined.nix) { });
+
+  regex = f final prev "regex" (final.callPackage (./pkgs/regex.nix) { });
+
+  regex-applicative = f final prev "regex-applicative" (final.callPackage (./pkgs/regex-applicative.nix) { });
+
+  regex-pcre-builtin = f final prev "regex-pcre-builtin" (final.callPackage (./pkgs/regex-pcre-builtin.nix) { });
+
+  replace-megaparsec = f final prev "replace-megaparsec" (final.callPackage (./pkgs/replace-megaparsec.nix) { });
+
+  req = f final prev "req" (final.callPackage (./pkgs/req.nix) { });
+
+  rope-utf16-splay = f final prev "rope-utf16-splay" (final.callPackage (./pkgs/rope-utf16-splay.nix) { });
+
+  row-types = f final prev "row-types" (final.callPackage (./pkgs/row-types.nix) { });
+
+  run-st = f final prev "run-st" (final.callPackage (./pkgs/run-st.nix) { });
+
+  rvar = f final prev "rvar" (final.callPackage (./pkgs/rvar.nix) { });
+
+  sandwich = f final prev "sandwich" (final.callPackage (./pkgs/sandwich.nix) { });
+
+  say = f final prev "say" (final.callPackage (./pkgs/say.nix) { });
+
+  scotty = f final prev "scotty" (final.callPackage (./pkgs/scotty.nix) { });
+
+  sel = f final prev "sel" (final.callPackage (./pkgs/sel.nix) { });
+
+  semver = f final prev "semver" (final.callPackage (./pkgs/semver.nix) { });
+
+  servant-blaze = f final prev "servant-blaze" (final.callPackage (./pkgs/servant-blaze.nix) { });
+
+  servant-effectful = f final prev "servant-effectful" (final.callPackage (./pkgs/servant-effectful.nix) { });
+
+  servant-lucid = f final prev "servant-lucid" (final.callPackage (./pkgs/servant-lucid.nix) { });
+
+  servant-openapi3 = f final prev "servant-openapi3" (final.callPackage (./pkgs/servant-openapi3.nix) { });
+
+  servant-static-th = f final prev "servant-static-th" (final.callPackage (./pkgs/servant-static-th.nix) { });
+
+  servant-websockets = f final prev "servant-websockets" (final.callPackage (./pkgs/servant-websockets.nix) { });
+
+  setlocale = f final prev "setlocale" (final.callPackage (./pkgs/setlocale.nix) { });
+
+  shelly = f final prev "shelly" (final.callPackage (./pkgs/shelly.nix) { });
+
+  show-combinators = f final prev "show-combinators" (final.callPackage (./pkgs/show-combinators.nix) { });
+
+  shower = f final prev "shower" (final.callPackage (./pkgs/shower.nix) { });
+
+  singletons = f final prev "singletons" (final.callPackage (./pkgs/singletons.nix) { });
+
+  size-based = f final prev "size-based" (final.callPackage (./pkgs/size-based.nix) { });
+
+  skylighting = f final prev "skylighting" (final.callPackage (./pkgs/skylighting.nix) { });
+
+  skylighting-core = f final prev "skylighting-core" (final.callPackage (./pkgs/skylighting-core.nix) { });
+
+  skylighting-format-ansi = f final prev "skylighting-format-ansi" (final.callPackage (./pkgs/skylighting-format-ansi.nix) { });
+
+  skylighting-format-blaze-html = f final prev "skylighting-format-blaze-html" (final.callPackage (./pkgs/skylighting-format-blaze-html.nix) { });
+
+  skylighting-format-context = f final prev "skylighting-format-context" (final.callPackage (./pkgs/skylighting-format-context.nix) { });
+
+  skylighting-format-latex = f final prev "skylighting-format-latex" (final.callPackage (./pkgs/skylighting-format-latex.nix) { });
+
+  slugify = f final prev "slugify" (final.callPackage (./pkgs/slugify.nix) { });
+
+  sort = f final prev "sort" (final.callPackage (./pkgs/sort.nix) { });
+
+  sorted-list = f final prev "sorted-list" (final.callPackage (./pkgs/sorted-list.nix) { });
+
+  souffle-haskell = f final prev "souffle-haskell" (final.callPackage (./pkgs/souffle-haskell.nix) { });
+
+  sourcemap = f final prev "sourcemap" (final.callPackage (./pkgs/sourcemap.nix) { });
+
+  sqlite-simple = f final prev "sqlite-simple" (final.callPackage (./pkgs/sqlite-simple.nix) { });
+
+  statestack = f final prev "statestack" (final.callPackage (./pkgs/statestack.nix) { });
+
+  statistics-linreg = f final prev "statistics-linreg" (final.callPackage (./pkgs/statistics-linreg.nix) { });
+
+  streaming = f final prev "streaming" (final.callPackage (./pkgs/streaming.nix) { });
+
+  streaming-binary = f final prev "streaming-binary" (final.callPackage (./pkgs/streaming-binary.nix) { });
+
+  streaming-bytestring = f final prev "streaming-bytestring" (final.callPackage (./pkgs/streaming-bytestring.nix) { });
+
+  streamly = f final prev "streamly" (final.callPackage (./pkgs/streamly.nix) { });
+
+  streamly-core = f final prev "streamly-core" (final.callPackage (./pkgs/streamly-core.nix) { });
+
+  strict-list = f final prev "strict-list" (final.callPackage (./pkgs/strict-list.nix) { });
+
+  string-conv = f final prev "string-conv" (final.callPackage (./pkgs/string-conv.nix) { });
+
+  stripeapi = f final prev "stripeapi" (final.callPackage (./pkgs/stripeapi.nix) { });
+
+  sundown = f final prev "sundown" (final.callPackage (./pkgs/sundown.nix) { });
+
+  tasty-hslua = f final prev "tasty-hslua" (final.callPackage (./pkgs/tasty-hslua.nix) { });
+
+  tasty-lua = f final prev "tasty-lua" (final.callPackage (./pkgs/tasty-lua.nix) { });
+
+  tasty-rerun = f final prev "tasty-rerun" (final.callPackage (./pkgs/tasty-rerun.nix) { });
+
+  tdigest = f final prev "tdigest" (final.callPackage (./pkgs/tdigest.nix) { });
+
+  template-haskell-compat-v0208 = f final prev "template-haskell-compat-v0208" (final.callPackage (./pkgs/template-haskell-compat-v0208.nix) { });
+
+  test-framework-smallcheck = f final prev "test-framework-smallcheck" (final.callPackage (./pkgs/test-framework-smallcheck.nix) { });
+
+  testing-feat = f final prev "testing-feat" (final.callPackage (./pkgs/testing-feat.nix) { });
+
+  testing-type-modifiers = f final prev "testing-type-modifiers" (final.callPackage (./pkgs/testing-type-modifiers.nix) { });
+
+  texmath = f final prev "texmath" (final.callPackage (./pkgs/texmath.nix) { });
+
+  text-ansi = f final prev "text-ansi" (final.callPackage (./pkgs/text-ansi.nix) { });
+
+  text-builder = f final prev "text-builder" (final.callPackage (./pkgs/text-builder.nix) { });
+
+  text-builder-dev = f final prev "text-builder-dev" (final.callPackage (./pkgs/text-builder-dev.nix) { });
+
+  text-builder-linear = f final prev "text-builder-linear" (final.callPackage (./pkgs/text-builder-linear.nix) { });
+
+  text-display = f final prev "text-display" (final.callPackage (./pkgs/text-display.nix) { });
+
+  text-icu = f final prev "text-icu" (final.callPackage (./pkgs/text-icu.nix) { });
+
+  text-latin1 = f final prev "text-latin1" (final.callPackage (./pkgs/text-latin1.nix) { });
+
+  text-printer = f final prev "text-printer" (final.callPackage (./pkgs/text-printer.nix) { });
+
+  text-rope = f final prev "text-rope" (final.callPackage (./pkgs/text-rope.nix) { });
+
+  th-desugar = f final prev "th-desugar" (final.callPackage (./pkgs/th-desugar.nix) { });
+
+  these-skinny = f final prev "these-skinny" (final.callPackage (./pkgs/these-skinny.nix) { });
+
+  thyme = f final prev "thyme" (final.callPackage (./pkgs/thyme.nix) { });
+
+  tidal = f final prev "tidal" (final.callPackage (./pkgs/tidal.nix) { });
+
+  tidal-link = f final prev "tidal-link" (final.callPackage (./pkgs/tidal-link.nix) { });
+
+  time-units = f final prev "time-units" (final.callPackage (./pkgs/time-units.nix) { });
+
+  timeit = f final prev "timeit" (final.callPackage (./pkgs/timeit.nix) { });
+
+  timing-convenience = f final prev "timing-convenience" (final.callPackage (./pkgs/timing-convenience.nix) { });
+
+  tmp-postgres = f final prev "tmp-postgres" (final.callPackage (./pkgs/tmp-postgres.nix) { });
+
+  toml-parser = f final prev "toml-parser" (final.callPackage (./pkgs/toml-parser.nix) { });
+
+  torsor = f final prev "torsor" (final.callPackage (./pkgs/torsor.nix) { });
+
+  transformers-except = f final prev "transformers-except" (final.callPackage (./pkgs/transformers-except.nix) { });
+
+  tuple = f final prev "tuple" (final.callPackage (./pkgs/tuple.nix) { });
+
+  tuples = f final prev "tuples" (final.callPackage (./pkgs/tuples.nix) { });
+
+  type-errors-pretty = f final prev "type-errors-pretty" (final.callPackage (./pkgs/type-errors-pretty.nix) { });
+
+  type-hint = f final prev "type-hint" (final.callPackage (./pkgs/type-hint.nix) { });
+
+  typed-process-effectful = f final prev "typed-process-effectful" (final.callPackage (./pkgs/typed-process-effectful.nix) { });
+
+  typerep-map = f final prev "typerep-map" (final.callPackage (./pkgs/typerep-map.nix) { });
+
+  typst = f final prev "typst" (final.callPackage (./pkgs/typst.nix) { });
+
+  typst-symbols = f final prev "typst-symbols" (final.callPackage (./pkgs/typst-symbols.nix) { });
+
+  uglymemo = f final prev "uglymemo" (final.callPackage (./pkgs/uglymemo.nix) { });
+
+  unicode-collation = f final prev "unicode-collation" (final.callPackage (./pkgs/unicode-collation.nix) { });
+
+  unicode-data = f final prev "unicode-data" (final.callPackage (./pkgs/unicode-data.nix) { });
+
+  unicode-transforms = f final prev "unicode-transforms" (final.callPackage (./pkgs/unicode-transforms.nix) { });
+
+  universe-reverse-instances = f final prev "universe-reverse-instances" (final.callPackage (./pkgs/universe-reverse-instances.nix) { });
+
+  unix-bytestring = f final prev "unix-bytestring" (final.callPackage (./pkgs/unix-bytestring.nix) { });
+
+  unix-memory = f final prev "unix-memory" (final.callPackage (./pkgs/unix-memory.nix) { });
+
+  unlifted = f final prev "unlifted" (final.callPackage (./pkgs/unlifted.nix) { });
+
+  uri-bytestring-aeson = f final prev "uri-bytestring-aeson" (final.callPackage (./pkgs/uri-bytestring-aeson.nix) { });
+
+  url-slug = f final prev "url-slug" (final.callPackage (./pkgs/url-slug.nix) { });
+
+  validation = f final prev "validation" (final.callPackage (./pkgs/validation.nix) { });
+
+  validity-case-insensitive = f final prev "validity-case-insensitive" (final.callPackage (./pkgs/validity-case-insensitive.nix) { });
+
+  validity-network-uri = f final prev "validity-network-uri" (final.callPackage (./pkgs/validity-network-uri.nix) { });
+
+  validity-path = f final prev "validity-path" (final.callPackage (./pkgs/validity-path.nix) { });
+
+  validity-persistent = f final prev "validity-persistent" (final.callPackage (./pkgs/validity-persistent.nix) { });
+
+  validity-primitive = f final prev "validity-primitive" (final.callPackage (./pkgs/validity-primitive.nix) { });
+
+  validity-time = f final prev "validity-time" (final.callPackage (./pkgs/validity-time.nix) { });
+
+  validity-uuid = f final prev "validity-uuid" (final.callPackage (./pkgs/validity-uuid.nix) { });
+
+  vector-sized = f final prev "vector-sized" (final.callPackage (./pkgs/vector-sized.nix) { });
+
+  wai-log = f final prev "wai-log" (final.callPackage (./pkgs/wai-log.nix) { });
+
+  wai-middleware-heartbeat = f final prev "wai-middleware-heartbeat" (final.callPackage (./pkgs/wai-middleware-heartbeat.nix) { });
+
+  wai-middleware-prometheus = f final prev "wai-middleware-prometheus" (final.callPackage (./pkgs/wai-middleware-prometheus.nix) { });
+
+  wai-middleware-static = f final prev "wai-middleware-static" (final.callPackage (./pkgs/wai-middleware-static.nix) { });
+
+  wai-websockets = f final prev "wai-websockets" (final.callPackage (./pkgs/wai-websockets.nix) { });
+
+  websockets = f final prev "websockets" (final.callPackage (./pkgs/websockets.nix) { });
+
+  wide-word = f final prev "wide-word" (final.callPackage (./pkgs/wide-word.nix) { });
+
+  wizards = f final prev "wizards" (final.callPackage (./pkgs/wizards.nix) { });
+
+  wl-pprint-text = f final prev "wl-pprint-text" (final.callPackage (./pkgs/wl-pprint-text.nix) { });
+
+  word-compat = f final prev "word-compat" (final.callPackage (./pkgs/word-compat.nix) { });
+
+  wuss = f final prev "wuss" (final.callPackage (./pkgs/wuss.nix) { });
+
+  xml-conduit-writer = f final prev "xml-conduit-writer" (final.callPackage (./pkgs/xml-conduit-writer.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, 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.4.1";
-  sha256 = "5e93609c1633e4b6636d0ac2b52c1d35228c13bd704a7849cb4e92b00ce27250";
+  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
+    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
+    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 = false;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
   hyperlinkSource = false;
-  homepage = "http://bnfc.digitalgrammars.com/";
+  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

@@ -3,13 +3,15 @@ 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 = false;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
@@ -17,4 +19,4 @@ mkDerivation {
   description = "Generalized booleans and numbers";
   license = lib.licenses.bsd3;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/Cabal-described.nix

-{ mkDerivation
-, Cabal
-, Cabal-syntax
-, QuickCheck
-, base
-, containers
-, fetchgit
-, lib
-, pretty
-, 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 = true;
-  enableExecutableProfiling = true;
-  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 = true;
-  enableExecutableProfiling = true;
-  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
-, Cabal-syntax
-, array
-, base
-, bytestring
-, 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 = true;
-  enableExecutableProfiling = true;
-  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/Decimal.nix

-{ mkDerivation
-, HUnit
-, QuickCheck
-, base
-, deepseq
-, lib
-, test-framework
-, test-framework-hunit
-, test-framework-quickcheck2
+{ mkDerivation, HUnit, QuickCheck, base, deepseq, lib
+, test-framework, test-framework-hunit, test-framework-quickcheck2
 }:
 mkDerivation {
   pname = "Decimal";
@@ -17,17 +10,12 @@ mkDerivation {
   enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base deepseq ];
   testHaskellDepends = [
-    base
-    deepseq
-    HUnit
-    QuickCheck
-    test-framework
-    test-framework-hunit
+    base deepseq HUnit QuickCheck test-framework test-framework-hunit
     test-framework-quickcheck2
   ];
   enableLibraryProfiling = true;
   enableExecutableProfiling = true;
-  doHaddock = false;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
@@ -36,4 +24,4 @@ mkDerivation {
   description = "Decimal numbers with variable precision";
   license = lib.licenses.bsd3;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/Diff.nix

-{ mkDerivation
-, QuickCheck
-, array
-, base
-, directory
-, lib
-, pretty
-, process
-, test-framework
-, test-framework-quickcheck2
-}:
-mkDerivation {
-  pname = "Diff";
-  version = "0.4.1";
-  sha256 = "fd5e4aaac7219bcbb14834fb8580ebe0aae905958d0ad74f5338ea290b372670";
-  isLibrary = true;
-  isExecutable = false;
-  enableSeparateDataOutput = false;
-  libraryHaskellDepends = [ array base pretty ];
-  testHaskellDepends = [
-    array
-    base
-    directory
-    pretty
-    process
-    QuickCheck
-    test-framework
-    test-framework-quickcheck2
-  ];
-  enableLibraryProfiling = true;
-  enableExecutableProfiling = true;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  description = "O(ND) diff algorithm in haskell";
-  license = lib.licenses.bsd3;
-  broken = false;
-}

pkgs/Glob.nix

-{ mkDerivation
-, HUnit
-, QuickCheck
-, base
-, containers
-, directory
-, dlist
-, filepath
-, lib
-, test-framework
-, test-framework-hunit
-, test-framework-quickcheck2
-, transformers
-, transformers-compat
-}:
-mkDerivation {
-  pname = "Glob";
-  version = "0.10.2";
-  sha256 = "6af672ac8427d35cbd42d64142dc288feab266f0be92dae3c696e8860d8173c0";
-  revision = "3";
-  editedCabalFile = "1080rd5073g87rfm5whimb72b75105lqanybrbsfi14gmvndnbfx";
-  isLibrary = true;
-  isExecutable = false;
-  enableSeparateDataOutput = false;
-  libraryHaskellDepends = [
-    base
-    containers
-    directory
-    dlist
-    filepath
-    transformers
-    transformers-compat
-  ];
-  testHaskellDepends = [
-    base
-    containers
-    directory
-    dlist
-    filepath
-    HUnit
-    QuickCheck
-    test-framework
-    test-framework-hunit
-    test-framework-quickcheck2
-    transformers
-    transformers-compat
-  ];
-  enableLibraryProfiling = true;
-  enableExecutableProfiling = true;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  homepage = "http://iki.fi/matti.niemenmaa/glob/";
-  description = "Globbing library";
-  license = lib.licenses.bsd3;
-  broken = false;
-}

pkgs/HTF.nix

-{ mkDerivation
-, Cabal
-, Diff
-, HUnit
-, QuickCheck
-, aeson
-, aeson-pretty
-, array
-, base
-, base64-bytestring
-, bytestring
-, containers
-, cpphs
-, directory
-, filepath
-, haskell-src
-, lib
-, lifted-base
-, monad-control
-, mtl
-, old-time
-, pretty
-, process
-, random
-, regex-compat
-, template-haskell
-, temporary
-, text
-, time
-, unix
-, unordered-containers
-, vector
-, xmlgen
-}:
-mkDerivation {
-  pname = "HTF";
-  version = "0.15.0.0";
-  sha256 = "d812c570804f300b7c8c5c5c5c40cea4ad87ffce699988c11a17ed9073fa4b9b";
-  isLibrary = true;
-  isExecutable = true;
-  enableSeparateDataOutput = false;
-  setupHaskellDepends = [ base Cabal process ];
-  libraryHaskellDepends = [
-    aeson
-    array
-    base
-    base64-bytestring
-    bytestring
-    containers
-    cpphs
-    Diff
-    directory
-    haskell-src
-    HUnit
-    lifted-base
-    monad-control
-    mtl
-    old-time
-    pretty
-    process
-    QuickCheck
-    random
-    regex-compat
-    text
-    time
-    unix
-    vector
-    xmlgen
-  ];
-  libraryToolDepends = [ cpphs ];
-  executableHaskellDepends = [
-    array
-    base
-    cpphs
-    directory
-    HUnit
-    mtl
-    old-time
-    random
-    text
-  ];
-  executableToolDepends = [ cpphs ];
-  testHaskellDepends = [
-    aeson
-    aeson-pretty
-    base
-    bytestring
-    directory
-    filepath
-    HUnit
-    mtl
-    process
-    random
-    regex-compat
-    template-haskell
-    temporary
-    text
-    unordered-containers
-  ];
-  enableLibraryProfiling = true;
-  enableExecutableProfiling = true;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  homepage = "https://github.com/skogsbaer/HTF/";
-  description = "The Haskell Test Framework";
-  license = lib.licenses.lgpl21Only;
-  broken = false;
-}

pkgs/HTTP.nix

-{ mkDerivation
-, HUnit
-, array
-, base
-, bytestring
-, deepseq
-, httpd-shed
-, 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 = true;
-  enableExecutableProfiling = true;
-  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/HUnit.nix

-{ mkDerivation, base, call-stack, deepseq, filepath, lib }:
-mkDerivation {
-  pname = "HUnit";
-  version = "1.6.2.0";
-  sha256 = "b0b7538871ffc058486fc00740886d2f3172f8fa6869936bfe83a5e10bd744ab";
-  isLibrary = true;
-  isExecutable = false;
-  enableSeparateDataOutput = false;
-  libraryHaskellDepends = [ base call-stack deepseq ];
-  testHaskellDepends = [ base call-stack deepseq filepath ];
-  enableLibraryProfiling = true;
-  enableExecutableProfiling = true;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  homepage = "https://github.com/hspec/HUnit#readme";
-  description = "A unit testing framework for Haskell";
-  license = lib.licenses.bsd3;
-  broken = false;
-}

pkgs/Hclip.nix

@@ -9,7 +9,7 @@ mkDerivation {
   libraryHaskellDepends = [ base mtl process strict ];
   enableLibraryProfiling = true;
   enableExecutableProfiling = true;
-  doHaddock = false;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
@@ -18,4 +18,4 @@ mkDerivation {
   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/HsOpenSSL.nix

-{ mkDerivation
-, Cabal
-, base
-, bytestring
-, lib
-, network
-, openssl
-, time
-}:
-mkDerivation {
-  pname = "HsOpenSSL";
-  version = "0.11.7.2";
-  sha256 = "8536c0939e52c990b2998a4ac5ff2b5886e1701b41b9934a87df8ec910754d7b";
-  revision = "3";
-  editedCabalFile = "0nsqxym87s48029laqba4nzwpk7nrk35x7wmpjqfnbrj82ddcshd";
-  isLibrary = true;
-  isExecutable = false;
-  enableSeparateDataOutput = false;
-  setupHaskellDepends = [ base Cabal ];
-  libraryHaskellDepends = [ base bytestring network time ];
-  librarySystemDepends = [ openssl ];
-  testHaskellDepends = [ base bytestring ];
-  enableLibraryProfiling = true;
-  enableExecutableProfiling = true;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  homepage = "https://github.com/haskell-cryptography/HsOpenSSL";
-  description = "Partial OpenSSL binding for Haskell";
-  license = lib.licenses.publicDomain;
-  broken = false;
-}

pkgs/HsYAML.nix

-{ mkDerivation
-, QuickCheck
-, base
-, bytestring
-, containers
-, deepseq
-, lib
-, mtl
-, parsec
-, tasty
-, tasty-quickcheck
-, text
-, transformers
+{ mkDerivation, QuickCheck, base, bytestring, containers, deepseq
+, lib, mtl, parsec, tasty, tasty-quickcheck, text, transformers
 }:
 mkDerivation {
   pname = "HsYAML";
-  version = "0.2.1.1";
-  sha256 = "465bb4fc90979c19bedf6db2053f9ac54537b4912d5827d7e2135d42ef5ef628";
-  revision = "1";
-  editedCabalFile = "0jmbgrjywcblrd8k6zzv2b5givdz83f479y15v5gs0r93z25xpmv";
+  version = "0.2.1.4";
+  sha256 = "b580a9463c1192ea4687950f07f582268e55e2c51c1874dcdade5a8b83da1a26";
   isLibrary = true;
   isExecutable = true;
   enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base
-    bytestring
-    containers
-    deepseq
-    mtl
-    parsec
-    text
-    transformers
+    base bytestring containers deepseq mtl parsec text transformers
   ];
   testHaskellDepends = [
-    base
-    bytestring
-    containers
-    mtl
-    QuickCheck
-    tasty
-    tasty-quickcheck
+    base bytestring containers mtl QuickCheck tasty tasty-quickcheck
     text
   ];
   enableLibraryProfiling = true;
   enableExecutableProfiling = true;
-  doHaddock = false;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
@@ -52,4 +26,4 @@ mkDerivation {
   description = "Pure Haskell YAML 1.2 processor";
   license = lib.licenses.gpl2Only;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/JuicyPixels.nix

-{ mkDerivation
-, base
-, binary
-, bytestring
-, containers
-, deepseq
-, lib
-, mtl
-, primitive
-, transformers
-, vector
-, zlib
-}:
-mkDerivation {
-  pname = "JuicyPixels";
-  version = "3.3.8";
-  sha256 = "d3a0f6ca3515a1b3d526cbf79f2e0b0aab57f208ab216f9c26437bbcd86fb63e";
-  isLibrary = true;
-  isExecutable = false;
-  enableSeparateDataOutput = false;
-  libraryHaskellDepends = [
-    base
-    binary
-    bytestring
-    containers
-    deepseq
-    mtl
-    primitive
-    transformers
-    vector
-    zlib
-  ];
-  enableLibraryProfiling = true;
-  enableExecutableProfiling = true;
-  doHaddock = false;
-  jailbreak = true;
-  doCheck = false;
-  doBenchmark = false;
-  hyperlinkSource = false;
-  homepage = "https://github.com/Twinside/Juicy.Pixels";
-  description = "Picture loading/serialization (in png, jpeg, bitmap, gif, tga, tiff and radiance)";
-  license = lib.licenses.bsd3;
-  broken = false;
-}

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 ];
+  libraryHaskellDepends = [ base newtype-generics ];
   enableLibraryProfiling = true;
   enableExecutableProfiling = true;
-  doHaddock = false;
+  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/mtl-compat.nix → pkgs/MonadPrompt.nix

 { mkDerivation, base, lib, mtl }:
 mkDerivation {
-  pname = "mtl-compat";
-  version = "0.2.2";
-  sha256 = "1955398fe2115674f47f553b2caaf928c6aa3424271a5cd13bc191e54bfe3a9e";
+  pname = "MonadPrompt";
+  version = "1.0.0.5";
+  sha256 = "b012cbbe83650f741c7b7f6eafcc89dec299b0ac74a758b6f3a8cdfc5d3bbeda";
   isLibrary = true;
   isExecutable = false;
   enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base mtl ];
   enableLibraryProfiling = true;
   enableExecutableProfiling = true;
-  doHaddock = false;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
   hyperlinkSource = false;
-  homepage = "https://github.com/haskell-compat/mtl-compat";
-  description = "Backported Control.Monad.Except module from mtl";
+  description = "MonadPrompt, implementation & examples";
   license = lib.licenses.bsd3;
   broken = false;
-}
+}
\ No newline at end of file

pkgs/fmlist.nix → pkgs/NumInstances.nix

 { mkDerivation, base, lib }:
 mkDerivation {
-  pname = "fmlist";
-  version = "0.9.4";
-  sha256 = "2dbdc1850e6768fd5f4e4c45d011ef6796d8b2d639ec200da7f4407ae02d09a6";
+  pname = "NumInstances";
+  version = "1.4";
+  sha256 = "cbdb2a49346f59ceb5ab38592d7bc52e5205580d431d0ac6d852fd9880e59679";
   isLibrary = true;
   isExecutable = false;
   enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   enableLibraryProfiling = true;
   enableExecutableProfiling = true;
-  doHaddock = false;
+  doHaddock = true;
   jailbreak = true;
   doCheck = false;
   doBenchmark = false;
   hyperlinkSource = false;
-  homepage = "https://github.com/sjoerdvisscher/fmlist";
-  description = "FoldMap lists";
+  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