diff --git a/flake.nix b/flake.nix
index 39c83c3355a395e64e6949be2444c73e979922c4..ae0006e440a73e1ff87ea0b8cda8a31b88b00683 100644
--- a/flake.nix
+++ b/flake.nix
@@ -11,7 +11,7 @@
         overrides-hp = import ./overlay.nix { inherit inputs pkgs; };
         configuration = import ./configuration.nix { inherit inputs pkgs; };
         hp = pkgs.haskell.packages.ghc942.override {
-          overrides = pkgs.lib.composeManyExtensions [overrides-hp configuration];
+          overrides = pkgs.lib.composeManyExtensions [ overrides-hp configuration ];
         };
         hp' = pkgs.lib.filterAttrs
           (n: v: v != null
diff --git a/overlay.nix b/overlay.nix
index 7ca97ea6b5ca2854e8ca1b58293bdd78bd760394..a6147d953bb4bdec917bafc2cc30f3b9db95649b 100644
--- a/overlay.nix
+++ b/overlay.nix
@@ -1,448 +1,448 @@
-{pkgs, ...}:
+{ pkgs, ... }:
 
 final: prev: with pkgs.haskell.lib; {
-    Cabal = prev.callPackage (./pkgs/Cabal.nix) { };
+  Cabal = prev.callPackage (./pkgs/Cabal.nix) { };
 
-    Cabal-QuickCheck = prev.callPackage (./pkgs/Cabal-QuickCheck.nix) { };
+  Cabal-QuickCheck = prev.callPackage (./pkgs/Cabal-QuickCheck.nix) { };
 
-    Cabal-described = prev.callPackage (./pkgs/Cabal-described.nix) { };
+  Cabal-described = prev.callPackage (./pkgs/Cabal-described.nix) { };
 
-    Cabal-syntax = prev.callPackage (./pkgs/Cabal-syntax.nix) { };
+  Cabal-syntax = prev.callPackage (./pkgs/Cabal-syntax.nix) { };
 
-    Cabal-tree-diff = prev.callPackage (./pkgs/Cabal-tree-diff.nix) { };
+  Cabal-tree-diff = prev.callPackage (./pkgs/Cabal-tree-diff.nix) { };
 
-    ChasingBottoms = prev.callPackage (./pkgs/ChasingBottoms.nix) { };
+  ChasingBottoms = prev.callPackage (./pkgs/ChasingBottoms.nix) { };
 
-    HTTP = prev.callPackage (./pkgs/HTTP.nix) { };
+  HTTP = prev.callPackage (./pkgs/HTTP.nix) { };
 
-    JuicyPixels = prev.callPackage (./pkgs/JuicyPixels.nix) { };
+  JuicyPixels = prev.callPackage (./pkgs/JuicyPixels.nix) { };
 
-    OneTuple = prev.callPackage (./pkgs/OneTuple.nix) { };
+  OneTuple = prev.callPackage (./pkgs/OneTuple.nix) { };
 
-    OpenGLRaw = prev.callPackage (./pkgs/OpenGLRaw.nix) { };
+  OpenGLRaw = prev.callPackage (./pkgs/OpenGLRaw.nix) { };
 
-    aeson = prev.callPackage (./pkgs/aeson.nix) { };
+  aeson = prev.callPackage (./pkgs/aeson.nix) { };
 
-    ansi-terminal = prev.callPackage (./pkgs/ansi-terminal.nix) { };
+  ansi-terminal = prev.callPackage (./pkgs/ansi-terminal.nix) { };
 
-    apecs = prev.callPackage (./pkgs/apecs.nix) { };
+  apecs = prev.callPackage (./pkgs/apecs.nix) { };
 
-    assoc = prev.callPackage (./pkgs/assoc.nix) { };
+  assoc = prev.callPackage (./pkgs/assoc.nix) { };
 
-    async = prev.callPackage (./pkgs/async.nix) { };
+  async = prev.callPackage (./pkgs/async.nix) { };
 
-    autodocodec-yaml = prev.callPackage (./pkgs/autodocodec-yaml.nix) { };
+  autodocodec-yaml = prev.callPackage (./pkgs/autodocodec-yaml.nix) { };
 
-    base-compat = prev.callPackage (./pkgs/base-compat.nix) { };
+  base-compat = prev.callPackage (./pkgs/base-compat.nix) { };
 
-    base-compat-batteries = prev.callPackage (./pkgs/base-compat-batteries.nix) { };
+  base-compat-batteries = prev.callPackage (./pkgs/base-compat-batteries.nix) { };
 
-    base64 = prev.callPackage (./pkgs/base64.nix) { };
+  base64 = prev.callPackage (./pkgs/base64.nix) { };
 
-    basement = prev.callPackage (./pkgs/basement.nix) { };
+  basement = prev.callPackage (./pkgs/basement.nix) { };
 
-    bimap = prev.callPackage (./pkgs/bimap.nix) { };
+  bimap = prev.callPackage (./pkgs/bimap.nix) { };
 
-    binary-orphans = prev.callPackage (./pkgs/binary-orphans.nix) { };
+  binary-orphans = prev.callPackage (./pkgs/binary-orphans.nix) { };
 
-    blaze-markup = prev.callPackage (./pkgs/blaze-markup.nix) { };
+  blaze-markup = prev.callPackage (./pkgs/blaze-markup.nix) { };
 
-    boring = prev.callPackage (./pkgs/boring.nix) { };
+  boring = prev.callPackage (./pkgs/boring.nix) { };
 
-    brick = prev.callPackage (./pkgs/brick.nix) { };
+  brick = prev.callPackage (./pkgs/brick.nix) { };
 
-    bsb-http-chunked = prev.callPackage (./pkgs/bsb-http-chunked.nix) { };
+  bsb-http-chunked = prev.callPackage (./pkgs/bsb-http-chunked.nix) { };
 
-    bytes = prev.callPackage (./pkgs/bytes.nix) { };
+  bytes = prev.callPackage (./pkgs/bytes.nix) { };
 
-    cabal-doctest = prev.callPackage (./pkgs/cabal-doctest.nix) { };
+  cabal-doctest = prev.callPackage (./pkgs/cabal-doctest.nix) { };
 
-    cabal-install = prev.callPackage (./pkgs/cabal-install.nix) { };
+  cabal-install = prev.callPackage (./pkgs/cabal-install.nix) { };
 
-    cabal-install-solver = prev.callPackage (./pkgs/cabal-install-solver.nix) { };
+  cabal-install-solver = prev.callPackage (./pkgs/cabal-install-solver.nix) { };
 
-    cborg = prev.callPackage (./pkgs/cborg.nix) { };
+  cborg = prev.callPackage (./pkgs/cborg.nix) { };
 
-    cborg-json = prev.callPackage (./pkgs/cborg-json.nix) { };
+  cborg-json = prev.callPackage (./pkgs/cborg-json.nix) { };
 
-    cereal = prev.callPackage (./pkgs/cereal.nix) { };
+  cereal = prev.callPackage (./pkgs/cereal.nix) { };
 
-    citeproc = prev.callPackage (./pkgs/citeproc.nix) { };
+  citeproc = prev.callPackage (./pkgs/citeproc.nix) { };
 
-    co-log-core = prev.callPackage (./pkgs/co-log-core.nix) { };
+  co-log-core = prev.callPackage (./pkgs/co-log-core.nix) { };
 
-    comonad = prev.callPackage (./pkgs/comonad.nix) { };
+  comonad = prev.callPackage (./pkgs/comonad.nix) { };
 
-    compact = prev.callPackage (./pkgs/compact.nix) { };
+  compact = prev.callPackage (./pkgs/compact.nix) { };
 
-    compactable = prev.callPackage (./pkgs/compactable.nix) { };
+  compactable = prev.callPackage (./pkgs/compactable.nix) { };
 
-    composite-base = prev.callPackage (./pkgs/composite-base.nix) { };
+  composite-base = prev.callPackage (./pkgs/composite-base.nix) { };
 
-    composite-cassava = prev.callPackage (./pkgs/composite-cassava.nix) { };
+  composite-cassava = prev.callPackage (./pkgs/composite-cassava.nix) { };
 
-    composite-dhall = prev.callPackage (./pkgs/composite-dhall.nix) { };
+  composite-dhall = prev.callPackage (./pkgs/composite-dhall.nix) { };
 
-    composite-lens-extra = prev.callPackage (./pkgs/composite-lens-extra.nix) { };
+  composite-lens-extra = prev.callPackage (./pkgs/composite-lens-extra.nix) { };
 
-    composite-tuple = prev.callPackage (./pkgs/composite-tuple.nix) { };
+  composite-tuple = prev.callPackage (./pkgs/composite-tuple.nix) { };
 
-    conduit = prev.callPackage (./pkgs/conduit.nix) { };
+  conduit = prev.callPackage (./pkgs/conduit.nix) { };
 
-    conduit-extra = prev.callPackage (./pkgs/conduit-extra.nix) { };
+  conduit-extra = prev.callPackage (./pkgs/conduit-extra.nix) { };
 
-    config-ini = prev.callPackage (./pkgs/config-ini.nix) { };
+  config-ini = prev.callPackage (./pkgs/config-ini.nix) { };
 
-    constraints = prev.callPackage (./pkgs/constraints.nix) { };
+  constraints = prev.callPackage (./pkgs/constraints.nix) { };
 
-    cryptohash-sha1 = prev.callPackage (./pkgs/cryptohash-sha1.nix) { };
+  cryptohash-sha1 = prev.callPackage (./pkgs/cryptohash-sha1.nix) { };
 
-    cryptonite = prev.callPackage (./pkgs/cryptonite.nix) { };
+  cryptonite = prev.callPackage (./pkgs/cryptonite.nix) { };
 
-    data-fix = prev.callPackage (./pkgs/data-fix.nix) { };
+  data-fix = prev.callPackage (./pkgs/data-fix.nix) { };
 
-    dec = prev.callPackage (./pkgs/dec.nix) { };
+  dec = prev.callPackage (./pkgs/dec.nix) { };
 
-    dhall = prev.callPackage (./pkgs/dhall.nix) { };
+  dhall = prev.callPackage (./pkgs/dhall.nix) { };
 
-    dimensional = prev.callPackage (./pkgs/dimensional.nix) { };
+  dimensional = prev.callPackage (./pkgs/dimensional.nix) { };
 
-    doctest = prev.callPackage (./pkgs/doctest.nix) { };
+  doctest = prev.callPackage (./pkgs/doctest.nix) { };
 
-    double-conversion = prev.callPackage (./pkgs/double-conversion.nix) { };
+  double-conversion = prev.callPackage (./pkgs/double-conversion.nix) { };
 
-    ed25519 = prev.callPackage (./pkgs/ed25519.nix) { };
+  ed25519 = prev.callPackage (./pkgs/ed25519.nix) { };
 
-    effectful = prev.callPackage (./pkgs/effectful.nix) { };
+  effectful = prev.callPackage (./pkgs/effectful.nix) { };
 
-    effectful-cache = prev.callPackage (./pkgs/effectful-cache.nix) { };
+  effectful-cache = prev.callPackage (./pkgs/effectful-cache.nix) { };
 
-    effectful-core = prev.callPackage (./pkgs/effectful-core.nix) { };
+  effectful-core = prev.callPackage (./pkgs/effectful-core.nix) { };
 
-    effectful-th = prev.callPackage (./pkgs/effectful-th.nix) { };
+  effectful-th = prev.callPackage (./pkgs/effectful-th.nix) { };
 
-    ema = prev.callPackage (./pkgs/ema.nix) { };
+  ema = prev.callPackage (./pkgs/ema.nix) { };
 
-    email-validate = prev.callPackage (./pkgs/email-validate.nix) { };
+  email-validate = prev.callPackage (./pkgs/email-validate.nix) { };
 
-    extra = prev.callPackage (./pkgs/extra.nix) { };
+  extra = prev.callPackage (./pkgs/extra.nix) { };
 
-    fcf-containers = prev.callPackage (./pkgs/fcf-containers.nix) { };
+  fcf-containers = prev.callPackage (./pkgs/fcf-containers.nix) { };
 
-    finite-field = prev.callPackage (./pkgs/finite-field.nix) { };
+  finite-field = prev.callPackage (./pkgs/finite-field.nix) { };
 
-    first-class-families = prev.callPackage (./pkgs/first-class-families.nix) { };
+  first-class-families = prev.callPackage (./pkgs/first-class-families.nix) { };
 
-    foldl = prev.callPackage (./pkgs/foldl.nix) { };
+  foldl = prev.callPackage (./pkgs/foldl.nix) { };
 
-    foundation = prev.callPackage (./pkgs/foundation.nix) { };
+  foundation = prev.callPackage (./pkgs/foundation.nix) { };
 
-    fourmolu = prev.callPackage (./pkgs/fourmolu.nix) { };
+  fourmolu = prev.callPackage (./pkgs/fourmolu.nix) { };
 
-    generic-lens-core = prev.callPackage (./pkgs/generic-lens-core.nix) { };
+  generic-lens-core = prev.callPackage (./pkgs/generic-lens-core.nix) { };
 
-    generic-lens-lite = prev.callPackage (./pkgs/generic-lens-lite.nix) { };
+  generic-lens-lite = prev.callPackage (./pkgs/generic-lens-lite.nix) { };
 
-    generic-optics = prev.callPackage (./pkgs/generic-optics.nix) { };
+  generic-optics = prev.callPackage (./pkgs/generic-optics.nix) { };
 
-    generic-optics-lite = prev.callPackage (./pkgs/generic-optics-lite.nix) { };
+  generic-optics-lite = prev.callPackage (./pkgs/generic-optics-lite.nix) { };
 
-    generics-sop = prev.callPackage (./pkgs/generics-sop.nix) { };
+  generics-sop = prev.callPackage (./pkgs/generics-sop.nix) { };
 
-    genvalidity-aeson = prev.callPackage (./pkgs/genvalidity-aeson.nix) { };
+  genvalidity-aeson = prev.callPackage (./pkgs/genvalidity-aeson.nix) { };
 
-    genvalidity-bytestring = prev.callPackage (./pkgs/genvalidity-bytestring.nix) { };
+  genvalidity-bytestring = prev.callPackage (./pkgs/genvalidity-bytestring.nix) { };
 
-    genvalidity-hspec = prev.callPackage (./pkgs/genvalidity-hspec.nix) { };
+  genvalidity-hspec = prev.callPackage (./pkgs/genvalidity-hspec.nix) { };
 
-    genvalidity-scientific = prev.callPackage (./pkgs/genvalidity-scientific.nix) { };
+  genvalidity-scientific = prev.callPackage (./pkgs/genvalidity-scientific.nix) { };
 
-    genvalidity-sydtest-aeson = prev.callPackage (./pkgs/genvalidity-sydtest-aeson.nix) { };
+  genvalidity-sydtest-aeson = prev.callPackage (./pkgs/genvalidity-sydtest-aeson.nix) { };
 
-    genvalidity-text = prev.callPackage (./pkgs/genvalidity-text.nix) { };
+  genvalidity-text = prev.callPackage (./pkgs/genvalidity-text.nix) { };
 
-    genvalidity-unordered-containers = prev.callPackage (./pkgs/genvalidity-unordered-containers.nix) { };
+  genvalidity-unordered-containers = prev.callPackage (./pkgs/genvalidity-unordered-containers.nix) { };
 
-    genvalidity-vector = prev.callPackage (./pkgs/genvalidity-vector.nix) { };
+  genvalidity-vector = prev.callPackage (./pkgs/genvalidity-vector.nix) { };
 
-    ghc-byteorder = prev.callPackage (./pkgs/ghc-byteorder.nix) { };
+  ghc-byteorder = prev.callPackage (./pkgs/ghc-byteorder.nix) { };
 
-    ghc-check = prev.callPackage (./pkgs/ghc-check.nix) { };
+  ghc-check = prev.callPackage (./pkgs/ghc-check.nix) { };
 
-    ghc-exactprint = prev.callPackage (./pkgs/ghc-exactprint.nix) { };
+  ghc-exactprint = prev.callPackage (./pkgs/ghc-exactprint.nix) { };
 
-    ghc-lib-parser = prev.callPackage (./pkgs/ghc-lib-parser.nix) { };
+  ghc-lib-parser = prev.callPackage (./pkgs/ghc-lib-parser.nix) { };
 
-    ghc-lib-parser-ex = prev.callPackage (./pkgs/ghc-lib-parser-ex.nix) { };
+  ghc-lib-parser-ex = prev.callPackage (./pkgs/ghc-lib-parser-ex.nix) { };
 
-    ghc-paths = prev.callPackage (./pkgs/ghc-paths.nix) { };
+  ghc-paths = prev.callPackage (./pkgs/ghc-paths.nix) { };
 
-    ghc-tcplugins-extra = prev.callPackage (./pkgs/ghc-tcplugins-extra.nix) { };
+  ghc-tcplugins-extra = prev.callPackage (./pkgs/ghc-tcplugins-extra.nix) { };
 
-    hackage-security = prev.callPackage (./pkgs/hackage-security.nix) { };
+  hackage-security = prev.callPackage (./pkgs/hackage-security.nix) { };
 
-    hashable = prev.callPackage (./pkgs/hashable.nix) { };
+  hashable = prev.callPackage (./pkgs/hashable.nix) { };
 
-    hashing = prev.callPackage (./pkgs/hashing.nix) { };
+  hashing = prev.callPackage (./pkgs/hashing.nix) { };
 
-    hashtables = prev.callPackage (./pkgs/hashtables.nix) { };
+  hashtables = prev.callPackage (./pkgs/hashtables.nix) { };
 
-    haskell-src-meta = prev.callPackage (./pkgs/haskell-src-meta.nix) { };
+  haskell-src-meta = prev.callPackage (./pkgs/haskell-src-meta.nix) { };
 
-    hedgehog = prev.callPackage (./pkgs/hedgehog.nix) { };
+  hedgehog = prev.callPackage (./pkgs/hedgehog.nix) { };
 
-    hedgehog-golden = prev.callPackage (./pkgs/hedgehog-golden.nix) { };
+  hedgehog-golden = prev.callPackage (./pkgs/hedgehog-golden.nix) { };
 
-    hie-compat = prev.callPackage (./pkgs/hie-compat.nix) { };
+  hie-compat = prev.callPackage (./pkgs/hie-compat.nix) { };
 
-    hiedb = prev.callPackage (./pkgs/hiedb.nix) { };
+  hiedb = prev.callPackage (./pkgs/hiedb.nix) { };
 
-    hlint = prev.callPackage (./pkgs/hlint.nix) { };
+  hlint = prev.callPackage (./pkgs/hlint.nix) { };
 
-    hnix = prev.callPackage (./pkgs/hnix.nix) { };
+  hnix = prev.callPackage (./pkgs/hnix.nix) { };
 
-    hourglass = prev.callPackage (./pkgs/hourglass.nix) { };
+  hourglass = prev.callPackage (./pkgs/hourglass.nix) { };
 
-    hslua-aeson = prev.callPackage (./pkgs/hslua-aeson.nix) { };
+  hslua-aeson = prev.callPackage (./pkgs/hslua-aeson.nix) { };
 
-    hspec = prev.callPackage (./pkgs/hspec.nix) { };
+  hspec = prev.callPackage (./pkgs/hspec.nix) { };
 
-    hspec-core = prev.callPackage (./pkgs/hspec-core.nix) { };
+  hspec-core = prev.callPackage (./pkgs/hspec-core.nix) { };
 
-    hspec-discover = prev.callPackage (./pkgs/hspec-discover.nix) { };
+  hspec-discover = prev.callPackage (./pkgs/hspec-discover.nix) { };
 
-    hspec-meta = prev.callPackage (./pkgs/hspec-meta.nix) { };
+  hspec-meta = prev.callPackage (./pkgs/hspec-meta.nix) { };
 
-    http-client = prev.callPackage (./pkgs/http-client.nix) { };
+  http-client = prev.callPackage (./pkgs/http-client.nix) { };
 
-    http-date = prev.callPackage (./pkgs/http-date.nix) { };
+  http-date = prev.callPackage (./pkgs/http-date.nix) { };
 
-    http-types = prev.callPackage (./pkgs/http-types.nix) { };
+  http-types = prev.callPackage (./pkgs/http-types.nix) { };
 
-    http2 = prev.callPackage (./pkgs/http2.nix) { };
+  http2 = prev.callPackage (./pkgs/http2.nix) { };
 
-    incipit-base = prev.callPackage (./pkgs/incipit-base.nix) { };
+  incipit-base = prev.callPackage (./pkgs/incipit-base.nix) { };
 
-    incipit-core = prev.callPackage (./pkgs/incipit-core.nix) { };
+  incipit-core = prev.callPackage (./pkgs/incipit-core.nix) { };
 
-    indexed-traversable = prev.callPackage (./pkgs/indexed-traversable.nix) { };
+  indexed-traversable = prev.callPackage (./pkgs/indexed-traversable.nix) { };
 
-    indexed-traversable-instances = prev.callPackage (./pkgs/indexed-traversable-instances.nix) { };
+  indexed-traversable-instances = prev.callPackage (./pkgs/indexed-traversable-instances.nix) { };
 
-    integer-logarithms = prev.callPackage (./pkgs/integer-logarithms.nix) { };
+  integer-logarithms = prev.callPackage (./pkgs/integer-logarithms.nix) { };
 
-    invariant = prev.callPackage (./pkgs/invariant.nix) { };
+  invariant = prev.callPackage (./pkgs/invariant.nix) { };
 
-    iproute = prev.callPackage (./pkgs/iproute.nix) { };
+  iproute = prev.callPackage (./pkgs/iproute.nix) { };
 
-    lens = prev.callPackage (./pkgs/lens.nix) { };
+  lens = prev.callPackage (./pkgs/lens.nix) { };
 
-    lens-aeson = prev.callPackage (./pkgs/lens-aeson.nix) { };
+  lens-aeson = prev.callPackage (./pkgs/lens-aeson.nix) { };
 
-    lens-family-th = prev.callPackage (./pkgs/lens-family-th.nix) { };
+  lens-family-th = prev.callPackage (./pkgs/lens-family-th.nix) { };
 
-    lifted-async = prev.callPackage (./pkgs/lifted-async.nix) { };
+  lifted-async = prev.callPackage (./pkgs/lifted-async.nix) { };
 
-    linear = prev.callPackage (./pkgs/linear.nix) { };
+  linear = prev.callPackage (./pkgs/linear.nix) { };
 
-    lsp = prev.callPackage (./pkgs/lsp.nix) { };
+  lsp = prev.callPackage (./pkgs/lsp.nix) { };
 
-    lsp-types = prev.callPackage (./pkgs/lsp-types.nix) { };
+  lsp-types = prev.callPackage (./pkgs/lsp-types.nix) { };
 
-    lucid = prev.callPackage (./pkgs/lucid.nix) { };
+  lucid = prev.callPackage (./pkgs/lucid.nix) { };
 
-    memory = prev.callPackage (./pkgs/memory.nix) { };
+  memory = prev.callPackage (./pkgs/memory.nix) { };
 
-    monoid-subclasses = prev.callPackage (./pkgs/monoid-subclasses.nix) { };
+  monoid-subclasses = prev.callPackage (./pkgs/monoid-subclasses.nix) { };
 
-    net-mqtt = prev.callPackage (./pkgs/net-mqtt.nix) { };
+  net-mqtt = prev.callPackage (./pkgs/net-mqtt.nix) { };
 
-    network-byte-order = prev.callPackage (./pkgs/network-byte-order.nix) { };
+  network-byte-order = prev.callPackage (./pkgs/network-byte-order.nix) { };
 
-    newtype-generics = prev.callPackage (./pkgs/newtype-generics.nix) { };
+  newtype-generics = prev.callPackage (./pkgs/newtype-generics.nix) { };
 
-    nothunks = prev.callPackage (./pkgs/nothunks.nix) { };
+  nothunks = prev.callPackage (./pkgs/nothunks.nix) { };
 
-    optics = prev.callPackage (./pkgs/optics.nix) { };
+  optics = prev.callPackage (./pkgs/optics.nix) { };
 
-    optics-core = prev.callPackage (./pkgs/optics-core.nix) { };
+  optics-core = prev.callPackage (./pkgs/optics-core.nix) { };
 
-    optics-extra = prev.callPackage (./pkgs/optics-extra.nix) { };
+  optics-extra = prev.callPackage (./pkgs/optics-extra.nix) { };
 
-    optics-th = prev.callPackage (./pkgs/optics-th.nix) { };
+  optics-th = prev.callPackage (./pkgs/optics-th.nix) { };
 
-    pandoc = prev.callPackage (./pkgs/pandoc.nix) { };
+  pandoc = prev.callPackage (./pkgs/pandoc.nix) { };
 
-    parallel = prev.callPackage (./pkgs/parallel.nix) { };
+  parallel = prev.callPackage (./pkgs/parallel.nix) { };
 
-    pcg-random = prev.callPackage (./pkgs/pcg-random.nix) { };
+  pcg-random = prev.callPackage (./pkgs/pcg-random.nix) { };
 
-    polysemy = prev.callPackage (./pkgs/polysemy.nix) { };
+  polysemy = prev.callPackage (./pkgs/polysemy.nix) { };
 
-    polysemy-extra = prev.callPackage (./pkgs/polysemy-extra.nix) { };
+  polysemy-extra = prev.callPackage (./pkgs/polysemy-extra.nix) { };
 
-    polysemy-kvstore = prev.callPackage (./pkgs/polysemy-kvstore.nix) { };
+  polysemy-kvstore = prev.callPackage (./pkgs/polysemy-kvstore.nix) { };
 
-    polysemy-methodology = prev.callPackage (./pkgs/polysemy-methodology.nix) { };
+  polysemy-methodology = prev.callPackage (./pkgs/polysemy-methodology.nix) { };
 
-    polysemy-path = prev.callPackage (./pkgs/polysemy-path.nix) { };
+  polysemy-path = prev.callPackage (./pkgs/polysemy-path.nix) { };
 
-    polysemy-plugin = prev.callPackage (./pkgs/polysemy-plugin.nix) { };
+  polysemy-plugin = prev.callPackage (./pkgs/polysemy-plugin.nix) { };
 
-    polysemy-several = prev.callPackage (./pkgs/polysemy-several.nix) { };
+  polysemy-several = prev.callPackage (./pkgs/polysemy-several.nix) { };
 
-    polysemy-time = prev.callPackage (./pkgs/polysemy-time.nix) { };
+  polysemy-time = prev.callPackage (./pkgs/polysemy-time.nix) { };
 
-    polysemy-vinyl = prev.callPackage (./pkgs/polysemy-vinyl.nix) { };
+  polysemy-vinyl = prev.callPackage (./pkgs/polysemy-vinyl.nix) { };
 
-    polysemy-zoo = prev.callPackage (./pkgs/polysemy-zoo.nix) { };
+  polysemy-zoo = prev.callPackage (./pkgs/polysemy-zoo.nix) { };
 
-    postgresql-libpq = prev.callPackage (./pkgs/postgresql-libpq.nix) { };
+  postgresql-libpq = prev.callPackage (./pkgs/postgresql-libpq.nix) { };
 
-    postgresql-simple = prev.callPackage (./pkgs/postgresql-simple.nix) { };
+  postgresql-simple = prev.callPackage (./pkgs/postgresql-simple.nix) { };
 
-    pretty-simple = prev.callPackage (./pkgs/pretty-simple.nix) { };
+  pretty-simple = prev.callPackage (./pkgs/pretty-simple.nix) { };
 
-    prettyprinter-ansi-terminal = prev.callPackage (./pkgs/prettyprinter-ansi-terminal.nix) { };
+  prettyprinter-ansi-terminal = prev.callPackage (./pkgs/prettyprinter-ansi-terminal.nix) { };
 
-    primitive = prev.callPackage (./pkgs/primitive.nix) { };
+  primitive = prev.callPackage (./pkgs/primitive.nix) { };
 
-    proteaaudio-sdl = prev.callPackage (./pkgs/proteaaudio-sdl.nix) { };
+  proteaaudio-sdl = prev.callPackage (./pkgs/proteaaudio-sdl.nix) { };
 
-    quickcheck-dynamic = prev.callPackage (./pkgs/quickcheck-dynamic.nix) { };
+  quickcheck-dynamic = prev.callPackage (./pkgs/quickcheck-dynamic.nix) { };
 
-    quickcheck-instances = prev.callPackage (./pkgs/quickcheck-instances.nix) { };
+  quickcheck-instances = prev.callPackage (./pkgs/quickcheck-instances.nix) { };
 
-    rebase = prev.callPackage (./pkgs/rebase.nix) { };
+  rebase = prev.callPackage (./pkgs/rebase.nix) { };
 
-    relude = prev.callPackage (./pkgs/relude.nix) { };
+  relude = prev.callPackage (./pkgs/relude.nix) { };
 
-    rerebase = prev.callPackage (./pkgs/rerebase.nix) { };
+  rerebase = prev.callPackage (./pkgs/rerebase.nix) { };
 
-    retry = prev.callPackage (./pkgs/retry.nix) { };
+  retry = prev.callPackage (./pkgs/retry.nix) { };
 
-    rope-utf16-splay = prev.callPackage (./pkgs/rope-utf16-splay.nix) { };
+  rope-utf16-splay = prev.callPackage (./pkgs/rope-utf16-splay.nix) { };
 
-    safe-coloured-text = prev.callPackage (./pkgs/safe-coloured-text.nix) { };
+  safe-coloured-text = prev.callPackage (./pkgs/safe-coloured-text.nix) { };
 
-    saltine = prev.callPackage (./pkgs/saltine.nix) { };
+  saltine = prev.callPackage (./pkgs/saltine.nix) { };
 
-    scientific = prev.callPackage (./pkgs/scientific.nix) { };
+  scientific = prev.callPackage (./pkgs/scientific.nix) { };
 
-    scotty = prev.callPackage (./pkgs/scotty.nix) { };
+  scotty = prev.callPackage (./pkgs/scotty.nix) { };
 
-    sdl2 = prev.callPackage (./pkgs/sdl2.nix) { };
+  sdl2 = prev.callPackage (./pkgs/sdl2.nix) { };
 
-    sdl2-gfx = prev.callPackage (./pkgs/sdl2-gfx.nix) { };
+  sdl2-gfx = prev.callPackage (./pkgs/sdl2-gfx.nix) { };
 
-    sdl2-image = prev.callPackage (./pkgs/sdl2-image.nix) { };
+  sdl2-image = prev.callPackage (./pkgs/sdl2-image.nix) { };
 
-    sdl2-mixer = prev.callPackage (./pkgs/sdl2-mixer.nix) { };
+  sdl2-mixer = prev.callPackage (./pkgs/sdl2-mixer.nix) { };
 
-    sdl2-ttf = prev.callPackage (./pkgs/sdl2-ttf.nix) { };
+  sdl2-ttf = prev.callPackage (./pkgs/sdl2-ttf.nix) { };
 
-    semialign = prev.callPackage (./pkgs/semialign.nix) { };
+  semialign = prev.callPackage (./pkgs/semialign.nix) { };
 
-    serialise = prev.callPackage (./pkgs/serialise.nix) { };
+  serialise = prev.callPackage (./pkgs/serialise.nix) { };
 
-    servant = prev.callPackage (./pkgs/servant.nix) { };
+  servant = prev.callPackage (./pkgs/servant.nix) { };
 
-    servant-client = prev.callPackage (./pkgs/servant-client.nix) { };
+  servant-client = prev.callPackage (./pkgs/servant-client.nix) { };
 
-    servant-client-core = prev.callPackage (./pkgs/servant-client-core.nix) { };
+  servant-client-core = prev.callPackage (./pkgs/servant-client-core.nix) { };
 
-    servant-foreign = prev.callPackage (./pkgs/servant-foreign.nix) { };
+  servant-foreign = prev.callPackage (./pkgs/servant-foreign.nix) { };
 
-    servant-lucid = prev.callPackage (./pkgs/servant-lucid.nix) { };
+  servant-lucid = prev.callPackage (./pkgs/servant-lucid.nix) { };
 
-    servant-multipart = prev.callPackage (./pkgs/servant-multipart.nix) { };
+  servant-multipart = prev.callPackage (./pkgs/servant-multipart.nix) { };
 
-    servant-multipart-api = prev.callPackage (./pkgs/servant-multipart-api.nix) { };
+  servant-multipart-api = prev.callPackage (./pkgs/servant-multipart-api.nix) { };
 
-    shake = prev.callPackage (./pkgs/shake.nix) { };
+  shake = prev.callPackage (./pkgs/shake.nix) { };
 
-    shelly = prev.callPackage (./pkgs/shelly.nix) { };
+  shelly = prev.callPackage (./pkgs/shelly.nix) { };
 
-    singleton-bool = prev.callPackage (./pkgs/singleton-bool.nix) { };
+  singleton-bool = prev.callPackage (./pkgs/singleton-bool.nix) { };
 
-    singletons = prev.callPackage (./pkgs/singletons.nix) { };
+  singletons = prev.callPackage (./pkgs/singletons.nix) { };
 
-    some = prev.callPackage (./pkgs/some.nix) { };
+  some = prev.callPackage (./pkgs/some.nix) { };
 
-    sop-core = prev.callPackage (./pkgs/sop-core.nix) { };
+  sop-core = prev.callPackage (./pkgs/sop-core.nix) { };
 
-    split = prev.callPackage (./pkgs/split.nix) { };
+  split = prev.callPackage (./pkgs/split.nix) { };
 
-    streaming-commons = prev.callPackage (./pkgs/streaming-commons.nix) { };
+  streaming-commons = prev.callPackage (./pkgs/streaming-commons.nix) { };
 
-    string-interpolate = prev.callPackage (./pkgs/string-interpolate.nix) { };
+  string-interpolate = prev.callPackage (./pkgs/string-interpolate.nix) { };
 
-    string-qq = prev.callPackage (./pkgs/string-qq.nix) { };
+  string-qq = prev.callPackage (./pkgs/string-qq.nix) { };
 
-    stylish-haskell = prev.callPackage (./pkgs/stylish-haskell.nix) { };
+  stylish-haskell = prev.callPackage (./pkgs/stylish-haskell.nix) { };
 
-    syb = prev.callPackage (./pkgs/syb.nix) { };
+  syb = prev.callPackage (./pkgs/syb.nix) { };
 
-    sydtest = prev.callPackage (./pkgs/sydtest.nix) { };
+  sydtest = prev.callPackage (./pkgs/sydtest.nix) { };
 
-    sydtest-discover = prev.callPackage (./pkgs/sydtest-discover.nix) { };
+  sydtest-discover = prev.callPackage (./pkgs/sydtest-discover.nix) { };
 
-    tasty = prev.callPackage (./pkgs/tasty.nix) { };
+  tasty = prev.callPackage (./pkgs/tasty.nix) { };
 
-    tasty-discover = prev.callPackage (./pkgs/tasty-discover.nix) { };
+  tasty-discover = prev.callPackage (./pkgs/tasty-discover.nix) { };
 
-    tasty-hedgehog = prev.callPackage (./pkgs/tasty-hedgehog.nix) { };
+  tasty-hedgehog = prev.callPackage (./pkgs/tasty-hedgehog.nix) { };
 
-    tasty-hunit = prev.callPackage (./pkgs/tasty-hunit.nix) { };
+  tasty-hunit = prev.callPackage (./pkgs/tasty-hunit.nix) { };
 
-    tasty-wai = prev.callPackage (./pkgs/tasty-wai.nix) { };
+  tasty-wai = prev.callPackage (./pkgs/tasty-wai.nix) { };
 
-    text-zipper = prev.callPackage (./pkgs/text-zipper.nix) { };
+  text-zipper = prev.callPackage (./pkgs/text-zipper.nix) { };
 
-    th-extras = prev.callPackage (./pkgs/th-extras.nix) { };
+  th-extras = prev.callPackage (./pkgs/th-extras.nix) { };
 
-    th-lift-instances = prev.callPackage (./pkgs/th-lift-instances.nix) { };
+  th-lift-instances = prev.callPackage (./pkgs/th-lift-instances.nix) { };
 
-    these = prev.callPackage (./pkgs/these.nix) { };
+  these = prev.callPackage (./pkgs/these.nix) { };
 
-    tidal = prev.callPackage (./pkgs/tidal.nix) { };
+  tidal = prev.callPackage (./pkgs/tidal.nix) { };
 
-    time-compat = prev.callPackage (./pkgs/time-compat.nix) { };
+  time-compat = prev.callPackage (./pkgs/time-compat.nix) { };
 
-    type-equality = prev.callPackage (./pkgs/type-equality.nix) { };
+  type-equality = prev.callPackage (./pkgs/type-equality.nix) { };
 
-    type-errors = prev.callPackage (./pkgs/type-errors.nix) { };
+  type-errors = prev.callPackage (./pkgs/type-errors.nix) { };
 
-    type-errors-pretty = prev.callPackage (./pkgs/type-errors-pretty.nix) { };
+  type-errors-pretty = prev.callPackage (./pkgs/type-errors-pretty.nix) { };
 
-    unicode-collation = prev.callPackage (./pkgs/unicode-collation.nix) { };
+  unicode-collation = prev.callPackage (./pkgs/unicode-collation.nix) { };
 
-    unicode-data = prev.callPackage (./pkgs/unicode-data.nix) { };
+  unicode-data = prev.callPackage (./pkgs/unicode-data.nix) { };
 
-    unicode-transforms = prev.callPackage (./pkgs/unicode-transforms.nix) { };
+  unicode-transforms = prev.callPackage (./pkgs/unicode-transforms.nix) { };
 
-    unordered-containers = prev.callPackage (./pkgs/unordered-containers.nix) { };
+  unordered-containers = prev.callPackage (./pkgs/unordered-containers.nix) { };
 
-    vault = prev.callPackage (./pkgs/vault.nix) { };
+  vault = prev.callPackage (./pkgs/vault.nix) { };
 
-    vector = prev.callPackage (./pkgs/vector.nix) { };
+  vector = prev.callPackage (./pkgs/vector.nix) { };
 
-    vector-algorithms = prev.callPackage (./pkgs/vector-algorithms.nix) { };
+  vector-algorithms = prev.callPackage (./pkgs/vector-algorithms.nix) { };
 
-    vinyl = prev.callPackage (./pkgs/vinyl.nix) { };
+  vinyl = prev.callPackage (./pkgs/vinyl.nix) { };
 
-    vty = prev.callPackage (./pkgs/vty.nix) { };
+  vty = prev.callPackage (./pkgs/vty.nix) { };
 
-    wai-middleware-static = prev.callPackage (./pkgs/wai-middleware-static.nix) { };
+  wai-middleware-static = prev.callPackage (./pkgs/wai-middleware-static.nix) { };
 
-    warp = prev.callPackage (./pkgs/warp.nix) { };
+  warp = prev.callPackage (./pkgs/warp.nix) { };
 
-    warp-tls = prev.callPackage (./pkgs/warp-tls.nix) { };
+  warp-tls = prev.callPackage (./pkgs/warp-tls.nix) { };
 
-    with-utf8 = prev.callPackage (./pkgs/with-utf8.nix) { };
+  with-utf8 = prev.callPackage (./pkgs/with-utf8.nix) { };
 
-    witherable = prev.callPackage (./pkgs/witherable.nix) { };
+  witherable = prev.callPackage (./pkgs/witherable.nix) { };
 
-    xml-conduit = prev.callPackage (./pkgs/xml-conduit.nix) { };
+  xml-conduit = prev.callPackage (./pkgs/xml-conduit.nix) { };
 
 }
diff --git a/pkgs/Cabal-QuickCheck.nix b/pkgs/Cabal-QuickCheck.nix
index 50b1ba0dee7fee409a7e80304c0c0866533e582d..4c696ea4d072134b186a7b0a859d77d4ff78cb99 100644
--- a/pkgs/Cabal-QuickCheck.nix
+++ b/pkgs/Cabal-QuickCheck.nix
@@ -1,5 +1,11 @@
-{ mkDerivation, base, bytestring, Cabal, Cabal-syntax, fetchgit
-, lib, QuickCheck
+{ mkDerivation
+, base
+, bytestring
+, Cabal
+, Cabal-syntax
+, fetchgit
+, lib
+, QuickCheck
 }:
 mkDerivation {
   pname = "Cabal-QuickCheck";
@@ -12,7 +18,11 @@ mkDerivation {
   };
   postUnpack = "sourceRoot+=/Cabal-QuickCheck/; echo source root reset to $sourceRoot";
   libraryHaskellDepends = [
-    base bytestring Cabal Cabal-syntax QuickCheck
+    base
+    bytestring
+    Cabal
+    Cabal-syntax
+    QuickCheck
   ];
   doHaddock = false;
   jailbreak = true;
@@ -20,4 +30,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "QuickCheck instances for types in Cabal";
   license = "unknown";
-}
\ No newline at end of file
+}
diff --git a/pkgs/Cabal-described.nix b/pkgs/Cabal-described.nix
index d153d031e16f0e4be71cd003ba9cd7761a8977cc..d4fbfde87a938544684653d6736ae68e52fedc9a 100644
--- a/pkgs/Cabal-described.nix
+++ b/pkgs/Cabal-described.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, base, Cabal, Cabal-syntax, containers, fetchgit
-, lib, pretty, QuickCheck, rere, tasty, tasty-quickcheck
+{ mkDerivation
+, base
+, Cabal
+, Cabal-syntax
+, containers
+, fetchgit
+, lib
+, pretty
+, QuickCheck
+, rere
+, tasty
+, tasty-quickcheck
 , transformers
 }:
 mkDerivation {
@@ -13,8 +23,16 @@ mkDerivation {
   };
   postUnpack = "sourceRoot+=/Cabal-described/; echo source root reset to $sourceRoot";
   libraryHaskellDepends = [
-    base Cabal Cabal-syntax containers pretty QuickCheck rere tasty
-    tasty-quickcheck transformers
+    base
+    Cabal
+    Cabal-syntax
+    containers
+    pretty
+    QuickCheck
+    rere
+    tasty
+    tasty-quickcheck
+    transformers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -22,4 +40,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Described functionality for types in Cabal";
   license = "unknown";
-}
\ No newline at end of file
+}
diff --git a/pkgs/Cabal-syntax.nix b/pkgs/Cabal-syntax.nix
index 41ae128da4ffefb43cc4874dd029d99a1360384d..298860bb291d19f6abff1a1a014fd0548b8e2202 100644
--- a/pkgs/Cabal-syntax.nix
+++ b/pkgs/Cabal-syntax.nix
@@ -1,6 +1,21 @@
-{ mkDerivation, array, base, binary, bytestring, containers
-, deepseq, directory, fetchgit, filepath, lib, mtl, parsec, pretty
-, text, time, transformers, unix
+{ mkDerivation
+, array
+, base
+, binary
+, bytestring
+, containers
+, deepseq
+, directory
+, fetchgit
+, filepath
+, lib
+, mtl
+, parsec
+, pretty
+, text
+, time
+, transformers
+, unix
 }:
 mkDerivation {
   pname = "Cabal-syntax";
@@ -13,8 +28,21 @@ mkDerivation {
   };
   postUnpack = "sourceRoot+=/Cabal-syntax/; echo source root reset to $sourceRoot";
   libraryHaskellDepends = [
-    array base binary bytestring containers deepseq directory filepath
-    mtl parsec pretty text time transformers unix
+    array
+    base
+    binary
+    bytestring
+    containers
+    deepseq
+    directory
+    filepath
+    mtl
+    parsec
+    pretty
+    text
+    time
+    transformers
+    unix
   ];
   doHaddock = false;
   jailbreak = true;
@@ -23,4 +51,4 @@ mkDerivation {
   homepage = "http://www.haskell.org/cabal/";
   description = "A library for working with .cabal files";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/Cabal-tree-diff.nix b/pkgs/Cabal-tree-diff.nix
index 8a9d13976e4150e6427d8b683f3b24c7db620818..fb503ac99c31364664c5c92dfb026c8d566a36a9 100644
--- a/pkgs/Cabal-tree-diff.nix
+++ b/pkgs/Cabal-tree-diff.nix
@@ -1,4 +1,10 @@
-{ mkDerivation, base, Cabal, Cabal-syntax, fetchgit, lib, tree-diff
+{ mkDerivation
+, base
+, Cabal
+, Cabal-syntax
+, fetchgit
+, lib
+, tree-diff
 }:
 mkDerivation {
   pname = "Cabal-tree-diff";
@@ -17,4 +23,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "QuickCheck instances for types in Cabal";
   license = "unknown";
-}
\ No newline at end of file
+}
diff --git a/pkgs/Cabal.nix b/pkgs/Cabal.nix
index e1287a05a3869b219e28aa1cdf8983c25305e93d..67d963aa15c1e2459b7550e718d6786e991f2bd5 100644
--- a/pkgs/Cabal.nix
+++ b/pkgs/Cabal.nix
@@ -1,6 +1,21 @@
-{ mkDerivation, array, base, bytestring, Cabal-syntax, containers
-, deepseq, directory, filepath, lib, mtl, parsec, pretty, process
-, text, time, transformers, unix
+{ mkDerivation
+, array
+, base
+, bytestring
+, Cabal-syntax
+, containers
+, deepseq
+, directory
+, filepath
+, lib
+, mtl
+, parsec
+, pretty
+, process
+, text
+, time
+, transformers
+, unix
 }:
 mkDerivation {
   pname = "Cabal";
@@ -8,8 +23,22 @@ mkDerivation {
   sha256 = "7464cbe6c2f3d7e5d0232023a1a7330621f8b24853cb259fc89a2af85b736608";
   setupHaskellDepends = [ mtl parsec ];
   libraryHaskellDepends = [
-    array base bytestring Cabal-syntax containers deepseq directory
-    filepath mtl parsec pretty process text time transformers unix
+    array
+    base
+    bytestring
+    Cabal-syntax
+    containers
+    deepseq
+    directory
+    filepath
+    mtl
+    parsec
+    pretty
+    process
+    text
+    time
+    transformers
+    unix
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +47,4 @@ mkDerivation {
   homepage = "http://www.haskell.org/cabal/";
   description = "A framework for packaging Haskell software";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ChasingBottoms.nix b/pkgs/ChasingBottoms.nix
index 61317b5a8bcf0b954e5b11a98b2dbf1dd4bafcb6..83ef3cd2688810116170f81da5d6ce23427deb75 100644
--- a/pkgs/ChasingBottoms.nix
+++ b/pkgs/ChasingBottoms.nix
@@ -1,15 +1,33 @@
-{ mkDerivation, array, base, containers, lib, mtl, QuickCheck
-, random, syb
+{ mkDerivation
+, array
+, base
+, containers
+, lib
+, mtl
+, QuickCheck
+, random
+, syb
 }:
 mkDerivation {
   pname = "ChasingBottoms";
   version = "1.3.1.12";
   sha256 = "a018538c0196390c7ebb5c677ff5b81bd760d75ae2b21bae8ab8a47b00f6c9ef";
   libraryHaskellDepends = [
-    base containers mtl QuickCheck random syb
+    base
+    containers
+    mtl
+    QuickCheck
+    random
+    syb
   ];
   testHaskellDepends = [
-    array base containers mtl QuickCheck random syb
+    array
+    base
+    containers
+    mtl
+    QuickCheck
+    random
+    syb
   ];
   doHaddock = false;
   jailbreak = true;
@@ -17,4 +35,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "For testing partial and infinite values";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/HTTP.nix b/pkgs/HTTP.nix
index 02fcf361c7a35f5adc6d07acebfd5ec840cf5965..29e12d3772e5291f9cc64072b10e39452565ba0a 100644
--- a/pkgs/HTTP.nix
+++ b/pkgs/HTTP.nix
@@ -1,6 +1,21 @@
-{ mkDerivation, array, base, bytestring, deepseq, httpd-shed, HUnit
-, lib, mtl, network, network-uri, parsec, pureMD5, split
-, test-framework, test-framework-hunit, time, transformers
+{ 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";
@@ -9,12 +24,29 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "04y04vbxbnblpmqqmpl8km4bkcjaj96nbxkssdr1zgbhqisxay5q";
   libraryHaskellDepends = [
-    array base bytestring mtl network network-uri parsec time
+    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
+    base
+    bytestring
+    deepseq
+    httpd-shed
+    HUnit
+    mtl
+    network
+    network-uri
+    pureMD5
+    split
+    test-framework
+    test-framework-hunit
   ];
   doHaddock = false;
   jailbreak = true;
@@ -23,4 +55,4 @@ mkDerivation {
   homepage = "https://github.com/haskell/HTTP";
   description = "A library for client-side HTTP";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/JuicyPixels.nix b/pkgs/JuicyPixels.nix
index 23af5de4ab20192716c011cbb17bf92ccc4edd0d..3fbc354ea067e64cb4fac9f16f86c52da0c419e7 100644
--- a/pkgs/JuicyPixels.nix
+++ b/pkgs/JuicyPixels.nix
@@ -1,13 +1,31 @@
-{ mkDerivation, base, binary, bytestring, containers, deepseq, lib
-, mtl, primitive, transformers, vector, zlib
+{ mkDerivation
+, base
+, binary
+, bytestring
+, containers
+, deepseq
+, lib
+, mtl
+, primitive
+, transformers
+, vector
+, zlib
 }:
 mkDerivation {
   pname = "JuicyPixels";
   version = "3.3.8";
   sha256 = "d3a0f6ca3515a1b3d526cbf79f2e0b0aab57f208ab216f9c26437bbcd86fb63e";
   libraryHaskellDepends = [
-    base binary bytestring containers deepseq mtl primitive
-    transformers vector zlib
+    base
+    binary
+    bytestring
+    containers
+    deepseq
+    mtl
+    primitive
+    transformers
+    vector
+    zlib
   ];
   doHaddock = false;
   jailbreak = true;
@@ -16,4 +34,4 @@ mkDerivation {
   homepage = "https://github.com/Twinside/Juicy.Pixels";
   description = "Picture loading/serialization (in png, jpeg, bitmap, gif, tga, tiff and radiance)";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/OneTuple.nix b/pkgs/OneTuple.nix
index 22c7463d48710709b8306eadce2f2d1caaefe76d..431da819a3cbe09ad778b4d4993c81bd1e2df41a 100644
--- a/pkgs/OneTuple.nix
+++ b/pkgs/OneTuple.nix
@@ -13,4 +13,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Singleton Tuple";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/OpenGLRaw.nix b/pkgs/OpenGLRaw.nix
index 0e6f57b4d5ad00321a3307b54360f1d60942f85b..ec7d9567edd7f844c6e20547d23768cbbe79ba46 100644
--- a/pkgs/OpenGLRaw.nix
+++ b/pkgs/OpenGLRaw.nix
@@ -1,12 +1,26 @@
-{ 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";
   libraryHaskellDepends = [
-    base bytestring containers fixed half text transformers
+    base
+    bytestring
+    containers
+    fixed
+    half
+    text
+    transformers
   ];
   librarySystemDepends = [ libGL ];
   doHaddock = false;
@@ -16,4 +30,4 @@ mkDerivation {
   homepage = "http://www.haskell.org/haskellwiki/Opengl";
   description = "A raw binding for the OpenGL graphics system";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/aeson.nix b/pkgs/aeson.nix
index 480ac3602887ba4639bddcc61cbdb1d76bc942a3..81eff4df555601f2068530b20020429e8d5ebf52 100644
--- a/pkgs/aeson.nix
+++ b/pkgs/aeson.nix
@@ -1,12 +1,48 @@
-{ mkDerivation, attoparsec, base, base-compat
-, base-compat-batteries, base-orphans, base16-bytestring
-, bytestring, containers, data-fix, deepseq, Diff, directory, dlist
-, filepath, generic-deriving, generically, ghc-prim, hashable
-, indexed-traversable, integer-logarithms, lib, OneTuple, primitive
-, QuickCheck, quickcheck-instances, scientific, semialign, strict
-, tagged, tasty, tasty-golden, tasty-hunit, tasty-quickcheck
-, template-haskell, text, text-short, th-abstraction, these, time
-, time-compat, unordered-containers, uuid-types, vector, witherable
+{ mkDerivation
+, attoparsec
+, base
+, base-compat
+, base-compat-batteries
+, base-orphans
+, base16-bytestring
+, bytestring
+, containers
+, data-fix
+, deepseq
+, Diff
+, directory
+, dlist
+, filepath
+, generic-deriving
+, generically
+, ghc-prim
+, hashable
+, indexed-traversable
+, integer-logarithms
+, lib
+, OneTuple
+, primitive
+, QuickCheck
+, quickcheck-instances
+, scientific
+, semialign
+, strict
+, tagged
+, tasty
+, tasty-golden
+, tasty-hunit
+, tasty-quickcheck
+, template-haskell
+, text
+, text-short
+, th-abstraction
+, these
+, time
+, time-compat
+, unordered-containers
+, uuid-types
+, vector
+, witherable
 }:
 mkDerivation {
   pname = "aeson";
@@ -15,21 +51,76 @@ mkDerivation {
   revision = "2";
   editedCabalFile = "0yp12cmkj5sz25kxzn6g1fz2d6acbq5rvff5dg2wg5zkjwfkhzqj";
   libraryHaskellDepends = [
-    attoparsec base base-compat-batteries bytestring containers
-    data-fix deepseq dlist generically ghc-prim hashable
-    indexed-traversable OneTuple primitive QuickCheck scientific
-    semialign strict tagged template-haskell text text-short
-    th-abstraction these time time-compat unordered-containers
-    uuid-types vector witherable
+    attoparsec
+    base
+    base-compat-batteries
+    bytestring
+    containers
+    data-fix
+    deepseq
+    dlist
+    generically
+    ghc-prim
+    hashable
+    indexed-traversable
+    OneTuple
+    primitive
+    QuickCheck
+    scientific
+    semialign
+    strict
+    tagged
+    template-haskell
+    text
+    text-short
+    th-abstraction
+    these
+    time
+    time-compat
+    unordered-containers
+    uuid-types
+    vector
+    witherable
   ];
   testHaskellDepends = [
-    attoparsec base base-compat base-orphans base16-bytestring
-    bytestring containers data-fix Diff directory dlist filepath
-    generic-deriving generically ghc-prim hashable indexed-traversable
-    integer-logarithms OneTuple primitive QuickCheck
-    quickcheck-instances scientific strict tagged tasty tasty-golden
-    tasty-hunit tasty-quickcheck template-haskell text text-short these
-    time time-compat unordered-containers uuid-types vector
+    attoparsec
+    base
+    base-compat
+    base-orphans
+    base16-bytestring
+    bytestring
+    containers
+    data-fix
+    Diff
+    directory
+    dlist
+    filepath
+    generic-deriving
+    generically
+    ghc-prim
+    hashable
+    indexed-traversable
+    integer-logarithms
+    OneTuple
+    primitive
+    QuickCheck
+    quickcheck-instances
+    scientific
+    strict
+    tagged
+    tasty
+    tasty-golden
+    tasty-hunit
+    tasty-quickcheck
+    template-haskell
+    text
+    text-short
+    these
+    time
+    time-compat
+    unordered-containers
+    uuid-types
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -38,4 +129,4 @@ mkDerivation {
   homepage = "https://github.com/haskell/aeson";
   description = "Fast JSON parsing and encoding";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ansi-terminal.nix b/pkgs/ansi-terminal.nix
index a0a258a1b9df55ed92c0ed5a961b55fdc5ee164e..ccbf7506374f9cdca0409b226355a1b5c5d8ab2d 100644
--- a/pkgs/ansi-terminal.nix
+++ b/pkgs/ansi-terminal.nix
@@ -13,4 +13,4 @@ mkDerivation {
   homepage = "https://github.com/UnkindPartition/ansi-terminal";
   description = "Simple ANSI terminal support, with Windows compatibility";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/apecs.nix b/pkgs/apecs.nix
index de181765b6b2322ac74e0aeb1ad23220c8890b86..dd571d31ee7133ba44f2104d93b72a657f107741 100644
--- a/pkgs/apecs.nix
+++ b/pkgs/apecs.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, array, base, containers, criterion, exceptions, lib
-, linear, mtl, QuickCheck, template-haskell, vector
+{ mkDerivation
+, array
+, base
+, containers
+, criterion
+, exceptions
+, lib
+, linear
+, mtl
+, QuickCheck
+, template-haskell
+, vector
 }:
 mkDerivation {
   pname = "apecs";
@@ -8,7 +18,13 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "1n0sz1230fp65dv462ss15yma6g1dxxlamj7idgl3kg9gdwv70sn";
   libraryHaskellDepends = [
-    array base containers exceptions mtl template-haskell vector
+    array
+    base
+    containers
+    exceptions
+    mtl
+    template-haskell
+    vector
   ];
   testHaskellDepends = [ base containers linear QuickCheck vector ];
   benchmarkHaskellDepends = [ base criterion linear ];
@@ -19,4 +35,4 @@ mkDerivation {
   homepage = "https://github.com/jonascarpay/apecs#readme";
   description = "Fast Entity-Component-System library for game programming";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/assoc.nix b/pkgs/assoc.nix
index 097f0048fdf3bbbeff2de66fc16899632b1e53d1..5e1df3f2e2e7d712ebb84da7159cdf0f1825772e 100644
--- a/pkgs/assoc.nix
+++ b/pkgs/assoc.nix
@@ -12,4 +12,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "swap and assoc: Symmetric and Semigroupy Bifunctors";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/async.nix b/pkgs/async.nix
index b4a75672246a4dbb41bedb76714a9b439f047c0a..e0fe384ebe6bf26881d688120c68a7afe3891bcd 100644
--- a/pkgs/async.nix
+++ b/pkgs/async.nix
@@ -1,4 +1,10 @@
-{ mkDerivation, base, hashable, HUnit, lib, stm, test-framework
+{ mkDerivation
+, base
+, hashable
+, HUnit
+, lib
+, stm
+, test-framework
 , test-framework-hunit
 }:
 mkDerivation {
@@ -11,7 +17,11 @@ mkDerivation {
   isExecutable = true;
   libraryHaskellDepends = [ base hashable stm ];
   testHaskellDepends = [
-    base HUnit stm test-framework test-framework-hunit
+    base
+    HUnit
+    stm
+    test-framework
+    test-framework-hunit
   ];
   doHaddock = false;
   jailbreak = true;
@@ -20,4 +30,4 @@ mkDerivation {
   homepage = "https://github.com/simonmar/async";
   description = "Run IO operations asynchronously and wait for their results";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/autodocodec-yaml.nix b/pkgs/autodocodec-yaml.nix
index 5c23ab0cfb2cee413c70ff46e7fe0b4f0923230a..cf0756d16a7087673e9d494a1b4adfb6d4016ab8 100644
--- a/pkgs/autodocodec-yaml.nix
+++ b/pkgs/autodocodec-yaml.nix
@@ -1,15 +1,37 @@
-{ mkDerivation, autodocodec, autodocodec-schema, base, bytestring
-, containers, lib, path, path-io, safe-coloured-text, scientific
-, text, unordered-containers, vector, yaml
+{ mkDerivation
+, autodocodec
+, autodocodec-schema
+, base
+, bytestring
+, containers
+, lib
+, path
+, path-io
+, safe-coloured-text
+, scientific
+, text
+, unordered-containers
+, vector
+, yaml
 }:
 mkDerivation {
   pname = "autodocodec-yaml";
   version = "0.2.0.2";
   sha256 = "3d5f811541866f95f44842227bc5d643e7dfa316f1b3075c22d9f3dc6fcd9698";
   libraryHaskellDepends = [
-    autodocodec autodocodec-schema base bytestring containers path
-    path-io safe-coloured-text scientific text unordered-containers
-    vector yaml
+    autodocodec
+    autodocodec-schema
+    base
+    bytestring
+    containers
+    path
+    path-io
+    safe-coloured-text
+    scientific
+    text
+    unordered-containers
+    vector
+    yaml
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +40,4 @@ mkDerivation {
   homepage = "https://github.com/NorfairKing/autodocodec#readme";
   description = "Autodocodec interpreters for yaml";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/base-compat-batteries.nix b/pkgs/base-compat-batteries.nix
index 62a36701066acbf7421dda506c0679703d119e6e..e9a13f4110e37c71f5b7b5694b0c7e7d5d833a30 100644
--- a/pkgs/base-compat-batteries.nix
+++ b/pkgs/base-compat-batteries.nix
@@ -1,5 +1,11 @@
-{ mkDerivation, base, base-compat, ghc-prim, hspec, hspec-discover
-, lib, QuickCheck
+{ mkDerivation
+, base
+, base-compat
+, ghc-prim
+, hspec
+, hspec-discover
+, lib
+, QuickCheck
 }:
 mkDerivation {
   pname = "base-compat-batteries";
@@ -14,4 +20,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "base-compat with extra batteries";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/base-compat.nix b/pkgs/base-compat.nix
index fb7596047b087ac6bb49035d20033f37b38d5532..00cfe3212fa8d82be168a1f9ec692879bd621069 100644
--- a/pkgs/base-compat.nix
+++ b/pkgs/base-compat.nix
@@ -10,4 +10,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "A compatibility layer for base";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/base64.nix b/pkgs/base64.nix
index 53c9304106c24162620c4b886b439f4344c7793d..cdf1df4a7140954ececfa482c584789e261f279c 100644
--- a/pkgs/base64.nix
+++ b/pkgs/base64.nix
@@ -1,6 +1,17 @@
-{ mkDerivation, base, base64-bytestring, bytestring, criterion
-, deepseq, lib, QuickCheck, random-bytestring, tasty, tasty-hunit
-, tasty-quickcheck, text, text-short
+{ mkDerivation
+, base
+, base64-bytestring
+, bytestring
+, criterion
+, deepseq
+, lib
+, QuickCheck
+, random-bytestring
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, text
+, text-short
 }:
 mkDerivation {
   pname = "base64";
@@ -9,15 +20,32 @@ mkDerivation {
   revision = "2";
   editedCabalFile = "0cz3zzz9k490w9nfn4hpgdw4zx4w70fwqrwsfx8svcwqssqibqw3";
   libraryHaskellDepends = [
-    base bytestring deepseq text text-short
+    base
+    bytestring
+    deepseq
+    text
+    text-short
   ];
   testHaskellDepends = [
-    base base64-bytestring bytestring QuickCheck random-bytestring
-    tasty tasty-hunit tasty-quickcheck text text-short
+    base
+    base64-bytestring
+    bytestring
+    QuickCheck
+    random-bytestring
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    text
+    text-short
   ];
   benchmarkHaskellDepends = [
-    base base64-bytestring bytestring criterion deepseq
-    random-bytestring text
+    base
+    base64-bytestring
+    bytestring
+    criterion
+    deepseq
+    random-bytestring
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -26,4 +54,4 @@ mkDerivation {
   homepage = "https://github.com/emilypi/base64";
   description = "A modern RFC 4648-compliant Base64 library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/basement.nix b/pkgs/basement.nix
index 83ab86d39e923894bd290960f84d7c61414747b4..8beff1f5e0d89b642bf428e119d6b255c9ced02c 100644
--- a/pkgs/basement.nix
+++ b/pkgs/basement.nix
@@ -11,4 +11,4 @@ mkDerivation {
   homepage = "https://github.com/haskell-foundation/foundation#readme";
   description = "Foundation scrap box of array & string";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/bimap.nix b/pkgs/bimap.nix
index 4780c0c7a336f16769dc29c9857c2188376dbb5c..6c588f4fedda854d26bfe8ab5a276a9d93cb320f 100644
--- a/pkgs/bimap.nix
+++ b/pkgs/bimap.nix
@@ -1,5 +1,11 @@
-{ mkDerivation, base, containers, deepseq, exceptions, lib
-, QuickCheck, template-haskell
+{ mkDerivation
+, base
+, containers
+, deepseq
+, exceptions
+, lib
+, QuickCheck
+, template-haskell
 }:
 mkDerivation {
   pname = "bimap";
@@ -7,7 +13,12 @@ mkDerivation {
   sha256 = "b0b44b0f2eaceb83f46dfa3d1747e080c45204c64d18bb9e63747299266f0c95";
   libraryHaskellDepends = [ base containers deepseq exceptions ];
   testHaskellDepends = [
-    base containers deepseq exceptions QuickCheck template-haskell
+    base
+    containers
+    deepseq
+    exceptions
+    QuickCheck
+    template-haskell
   ];
   doHaddock = false;
   jailbreak = true;
@@ -16,4 +27,4 @@ mkDerivation {
   homepage = "https://github.com/joelwilliamson/bimap";
   description = "Bidirectional mapping between two key types";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/binary-orphans.nix b/pkgs/binary-orphans.nix
index 27d50fb0d7c37c370ad73fb9e646e8975055795f..8aa7392ed699879214ac85c0c700b4f4fd438a5a 100644
--- a/pkgs/binary-orphans.nix
+++ b/pkgs/binary-orphans.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, base, binary, lib, OneTuple, QuickCheck
-, quickcheck-instances, tagged, tasty, tasty-quickcheck
+{ mkDerivation
+, base
+, binary
+, lib
+, OneTuple
+, QuickCheck
+, quickcheck-instances
+, tagged
+, tasty
+, tasty-quickcheck
 , transformers
 }:
 mkDerivation {
@@ -8,7 +16,13 @@ mkDerivation {
   sha256 = "e2e554823ce6758cbbfb64acb8b5905d3c226eab18b5fcaf5d7c79252114602c";
   libraryHaskellDepends = [ base binary transformers ];
   testHaskellDepends = [
-    base binary OneTuple QuickCheck quickcheck-instances tagged tasty
+    base
+    binary
+    OneTuple
+    QuickCheck
+    quickcheck-instances
+    tagged
+    tasty
     tasty-quickcheck
   ];
   doHaddock = false;
@@ -17,4 +31,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Compatibility package for binary; provides instances";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/blaze-markup.nix b/pkgs/blaze-markup.nix
index 0af12ab7979ac136f84c207f5ed5859f97931b31..715005f49227f4a8e9a61e2add595c7647003043 100644
--- a/pkgs/blaze-markup.nix
+++ b/pkgs/blaze-markup.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, base, blaze-builder, bytestring, containers, HUnit
-, lib, QuickCheck, tasty, tasty-hunit, tasty-quickcheck, text
+{ mkDerivation
+, base
+, blaze-builder
+, bytestring
+, containers
+, HUnit
+, lib
+, QuickCheck
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, text
 }:
 mkDerivation {
   pname = "blaze-markup";
@@ -9,8 +19,16 @@ mkDerivation {
   editedCabalFile = "1hn694kk615prqdn7bfzl0wvbw8bksxk4cxwmx8yhwpl0cq3fiwa";
   libraryHaskellDepends = [ base blaze-builder bytestring text ];
   testHaskellDepends = [
-    base blaze-builder bytestring containers HUnit QuickCheck tasty
-    tasty-hunit tasty-quickcheck text
+    base
+    blaze-builder
+    bytestring
+    containers
+    HUnit
+    QuickCheck
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -19,4 +37,4 @@ mkDerivation {
   homepage = "http://jaspervdj.be/blaze";
   description = "A blazingly fast markup combinator library for Haskell";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/boring.nix b/pkgs/boring.nix
index 48e1f6af8e8d9c625670a95e1d10af52aa2ff96c..0e7722d27164b8522477ffc36c8ad7fce1648dad 100644
--- a/pkgs/boring.nix
+++ b/pkgs/boring.nix
@@ -13,4 +13,4 @@ mkDerivation {
   homepage = "https://github.com/phadej/boring";
   description = "Boring and Absurd types";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/brick.nix b/pkgs/brick.nix
index f09273673661d013755432c1000083277ca4137d..2b24289f616261e6b4e1c87c4abb4cfe70062231 100644
--- a/pkgs/brick.nix
+++ b/pkgs/brick.nix
@@ -1,8 +1,29 @@
-{ mkDerivation, base, bimap, bytestring, config-ini, containers
-, contravariant, data-clist, deepseq, directory, exceptions
-, filepath, lib, microlens, microlens-mtl, microlens-th, mtl
-, QuickCheck, stm, template-haskell, text, text-zipper, unix
-, vector, vty, word-wrap
+{ mkDerivation
+, base
+, bimap
+, bytestring
+, config-ini
+, containers
+, contravariant
+, data-clist
+, deepseq
+, directory
+, exceptions
+, filepath
+, lib
+, microlens
+, microlens-mtl
+, microlens-th
+, mtl
+, QuickCheck
+, stm
+, template-haskell
+, text
+, text-zipper
+, unix
+, vector
+, vty
+, word-wrap
 }:
 mkDerivation {
   pname = "brick";
@@ -11,13 +32,37 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base bimap bytestring config-ini containers contravariant
-    data-clist deepseq directory exceptions filepath microlens
-    microlens-mtl microlens-th mtl stm template-haskell text
-    text-zipper unix vector vty word-wrap
+    base
+    bimap
+    bytestring
+    config-ini
+    containers
+    contravariant
+    data-clist
+    deepseq
+    directory
+    exceptions
+    filepath
+    microlens
+    microlens-mtl
+    microlens-th
+    mtl
+    stm
+    template-haskell
+    text
+    text-zipper
+    unix
+    vector
+    vty
+    word-wrap
   ];
   testHaskellDepends = [
-    base containers microlens QuickCheck vector vty
+    base
+    containers
+    microlens
+    QuickCheck
+    vector
+    vty
   ];
   doHaddock = false;
   jailbreak = true;
@@ -26,4 +71,4 @@ mkDerivation {
   homepage = "https://github.com/jtdaugherty/brick/";
   description = "A declarative terminal user interface library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/bsb-http-chunked.nix b/pkgs/bsb-http-chunked.nix
index 1057e0bb9e13dcab5ad3dac5f76cafdb0bd2b789..935384ab5f4dc0db6e0705245fa218306256ee12 100644
--- a/pkgs/bsb-http-chunked.nix
+++ b/pkgs/bsb-http-chunked.nix
@@ -1,6 +1,17 @@
-{ mkDerivation, attoparsec, base, blaze-builder, bytestring
-, deepseq, doctest, gauge, hedgehog, lib, semigroups, tasty
-, tasty-hedgehog, tasty-hunit
+{ mkDerivation
+, attoparsec
+, base
+, blaze-builder
+, bytestring
+, deepseq
+, doctest
+, gauge
+, hedgehog
+, lib
+, semigroups
+, tasty
+, tasty-hedgehog
+, tasty-hunit
 }:
 mkDerivation {
   pname = "bsb-http-chunked";
@@ -10,11 +21,23 @@ mkDerivation {
   editedCabalFile = "15hg352id2f4x0dnvv47bdiz6gv5hp5a2mki9yzmhc7ajpk31mdd";
   libraryHaskellDepends = [ base bytestring ];
   testHaskellDepends = [
-    attoparsec base blaze-builder bytestring doctest hedgehog tasty
-    tasty-hedgehog tasty-hunit
+    attoparsec
+    base
+    blaze-builder
+    bytestring
+    doctest
+    hedgehog
+    tasty
+    tasty-hedgehog
+    tasty-hunit
   ];
   benchmarkHaskellDepends = [
-    base blaze-builder bytestring deepseq gauge semigroups
+    base
+    blaze-builder
+    bytestring
+    deepseq
+    gauge
+    semigroups
   ];
   doHaddock = false;
   jailbreak = true;
@@ -23,4 +46,4 @@ mkDerivation {
   homepage = "http://github.com/sjakobi/bsb-http-chunked";
   description = "Chunked HTTP transfer encoding for bytestring builders";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/bytes.nix b/pkgs/bytes.nix
index 9cad5302657fb31bb5dec843bc71b7fa190cf9d8..3455ea2cd6e06aecba7424eacac3b6d3739818e8 100644
--- a/pkgs/bytes.nix
+++ b/pkgs/bytes.nix
@@ -1,6 +1,20 @@
-{ mkDerivation, base, binary, binary-orphans, bytestring, cereal
-, containers, hashable, lib, mtl, scientific, text, time
-, transformers, transformers-compat, unordered-containers, void
+{ mkDerivation
+, base
+, binary
+, binary-orphans
+, bytestring
+, cereal
+, containers
+, hashable
+, lib
+, mtl
+, scientific
+, text
+, time
+, transformers
+, transformers-compat
+, unordered-containers
+, void
 }:
 mkDerivation {
   pname = "bytes";
@@ -9,9 +23,21 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "0frs6ag93kmg2fw3vd686czx8g7h9qmdn1ip6wdk96d94ap0fz9i";
   libraryHaskellDepends = [
-    base binary binary-orphans bytestring cereal containers hashable
-    mtl scientific text time transformers transformers-compat
-    unordered-containers void
+    base
+    binary
+    binary-orphans
+    bytestring
+    cereal
+    containers
+    hashable
+    mtl
+    scientific
+    text
+    time
+    transformers
+    transformers-compat
+    unordered-containers
+    void
   ];
   doHaddock = false;
   jailbreak = true;
@@ -20,4 +46,4 @@ mkDerivation {
   homepage = "https://github.com/ekmett/bytes";
   description = "Sharing code for serialization between binary and cereal";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/cabal-doctest.nix b/pkgs/cabal-doctest.nix
index 0a7f99b23c3b27a01d8991996708bc90f6ee4c20..f89090867d7704268ba829c87644951b1dd00578 100644
--- a/pkgs/cabal-doctest.nix
+++ b/pkgs/cabal-doctest.nix
@@ -13,4 +13,4 @@ mkDerivation {
   homepage = "https://github.com/haskellari/cabal-doctest";
   description = "A Setup.hs helper for running doctests";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/cabal-install-solver.nix b/pkgs/cabal-install-solver.nix
index 4098bd55489dd5fc5dd45d7c5de56a4e9c4f96ae..ee92b24b71d393c4100e7512b35af20321a4e0d3 100644
--- a/pkgs/cabal-install-solver.nix
+++ b/pkgs/cabal-install-solver.nix
@@ -1,17 +1,44 @@
-{ mkDerivation, array, base, bytestring, Cabal, Cabal-syntax
-, containers, edit-distance, filepath, lib, mtl, pretty, tasty
-, tasty-hunit, tasty-quickcheck, transformers
+{ mkDerivation
+, array
+, base
+, bytestring
+, Cabal
+, Cabal-syntax
+, containers
+, edit-distance
+, filepath
+, lib
+, mtl
+, pretty
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, transformers
 }:
 mkDerivation {
   pname = "cabal-install-solver";
   version = "3.8.1.0";
   sha256 = "df2369f6c37517a3b2625bc19057d9e206bbb40386bcb607f17dc7d2e588ffe7";
   libraryHaskellDepends = [
-    array base bytestring Cabal Cabal-syntax containers edit-distance
-    filepath mtl pretty transformers
+    array
+    base
+    bytestring
+    Cabal
+    Cabal-syntax
+    containers
+    edit-distance
+    filepath
+    mtl
+    pretty
+    transformers
   ];
   testHaskellDepends = [
-    base Cabal Cabal-syntax tasty tasty-hunit tasty-quickcheck
+    base
+    Cabal
+    Cabal-syntax
+    tasty
+    tasty-hunit
+    tasty-quickcheck
   ];
   doHaddock = false;
   jailbreak = true;
@@ -20,4 +47,4 @@ mkDerivation {
   homepage = "http://www.haskell.org/cabal/";
   description = "The command-line interface for Cabal and Hackage";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/cabal-install.nix b/pkgs/cabal-install.nix
index cf258b2700527773e19e82c89ebde0d72c37c738..2fe4c97c5fd7de099b04974a8082512bb68d7194 100644
--- a/pkgs/cabal-install.nix
+++ b/pkgs/cabal-install.nix
@@ -1,12 +1,53 @@
-{ mkDerivation, array, async, base, base16-bytestring, binary
-, bytestring, Cabal, Cabal-described, cabal-install-solver
-, Cabal-QuickCheck, Cabal-syntax, Cabal-tree-diff, containers
-, cryptohash-sha256, directory, echo, edit-distance, exceptions
-, filepath, hackage-security, hashable, HTTP, lib, lukko, mtl
-, network-uri, parsec, pretty, pretty-show, process, QuickCheck
-, random, regex-base, regex-posix, resolv, safe-exceptions, stm
-, tagged, tar, tasty, tasty-expected-failure, tasty-golden
-, tasty-hunit, tasty-quickcheck, text, time, tree-diff, unix, zlib
+{ mkDerivation
+, array
+, async
+, base
+, base16-bytestring
+, binary
+, bytestring
+, Cabal
+, Cabal-described
+, cabal-install-solver
+, Cabal-QuickCheck
+, Cabal-syntax
+, Cabal-tree-diff
+, containers
+, cryptohash-sha256
+, directory
+, echo
+, edit-distance
+, exceptions
+, filepath
+, hackage-security
+, hashable
+, HTTP
+, lib
+, lukko
+, mtl
+, network-uri
+, parsec
+, pretty
+, pretty-show
+, process
+, QuickCheck
+, random
+, regex-base
+, regex-posix
+, resolv
+, safe-exceptions
+, stm
+, tagged
+, tar
+, tasty
+, tasty-expected-failure
+, tasty-golden
+, tasty-hunit
+, tasty-quickcheck
+, text
+, time
+, tree-diff
+, unix
+, zlib
 }:
 mkDerivation {
   pname = "cabal-install";
@@ -17,22 +58,79 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    array async base base16-bytestring binary bytestring Cabal
-    cabal-install-solver Cabal-syntax containers cryptohash-sha256
-    directory echo edit-distance exceptions filepath hackage-security
-    hashable HTTP lukko mtl network-uri parsec pretty process random
-    regex-base regex-posix resolv safe-exceptions stm tar text time
-    unix zlib
+    array
+    async
+    base
+    base16-bytestring
+    binary
+    bytestring
+    Cabal
+    cabal-install-solver
+    Cabal-syntax
+    containers
+    cryptohash-sha256
+    directory
+    echo
+    edit-distance
+    exceptions
+    filepath
+    hackage-security
+    hashable
+    HTTP
+    lukko
+    mtl
+    network-uri
+    parsec
+    pretty
+    process
+    random
+    regex-base
+    regex-posix
+    resolv
+    safe-exceptions
+    stm
+    tar
+    text
+    time
+    unix
+    zlib
   ];
   executableHaskellDepends = [
-    base Cabal Cabal-syntax directory filepath
+    base
+    Cabal
+    Cabal-syntax
+    directory
+    filepath
   ];
   testHaskellDepends = [
-    array base bytestring Cabal Cabal-described cabal-install-solver
-    Cabal-QuickCheck Cabal-syntax Cabal-tree-diff containers directory
-    filepath hashable mtl network-uri pretty-show QuickCheck random
-    tagged tar tasty tasty-expected-failure tasty-golden tasty-hunit
-    tasty-quickcheck time tree-diff zlib
+    array
+    base
+    bytestring
+    Cabal
+    Cabal-described
+    cabal-install-solver
+    Cabal-QuickCheck
+    Cabal-syntax
+    Cabal-tree-diff
+    containers
+    directory
+    filepath
+    hashable
+    mtl
+    network-uri
+    pretty-show
+    QuickCheck
+    random
+    tagged
+    tar
+    tasty
+    tasty-expected-failure
+    tasty-golden
+    tasty-hunit
+    tasty-quickcheck
+    time
+    tree-diff
+    zlib
   ];
   doHaddock = false;
   jailbreak = true;
@@ -46,4 +144,4 @@ mkDerivation {
   description = "The command-line interface for Cabal and Hackage";
   license = lib.licenses.bsd3;
   mainProgram = "cabal";
-}
\ No newline at end of file
+}
diff --git a/pkgs/cborg-json.nix b/pkgs/cborg-json.nix
index c8ebaa9fcbe3b94f16d5d5532e9acff2d385ee0a..39103b81d1f5f884b38748ebd52b8ab600f13b08 100644
--- a/pkgs/cborg-json.nix
+++ b/pkgs/cborg-json.nix
@@ -1,17 +1,43 @@
-{ mkDerivation, aeson, aeson-pretty, base, bytestring, cborg
-, criterion, deepseq, directory, lib, process, scientific, text
-, unordered-containers, vector, zlib
+{ mkDerivation
+, aeson
+, aeson-pretty
+, base
+, bytestring
+, cborg
+, criterion
+, deepseq
+, directory
+, lib
+, process
+, scientific
+, text
+, unordered-containers
+, vector
+, zlib
 }:
 mkDerivation {
   pname = "cborg-json";
   version = "0.2.5.0";
   sha256 = "58c373453f06fd8558e062c4fbe6dd862cb0ae28ac3c02ba3b607573bd077cd4";
   libraryHaskellDepends = [
-    aeson aeson-pretty base cborg scientific text unordered-containers
+    aeson
+    aeson-pretty
+    base
+    cborg
+    scientific
+    text
+    unordered-containers
     vector
   ];
   benchmarkHaskellDepends = [
-    aeson base bytestring cborg criterion deepseq directory process
+    aeson
+    base
+    bytestring
+    cborg
+    criterion
+    deepseq
+    directory
+    process
     zlib
   ];
   doHaddock = false;
@@ -21,4 +47,4 @@ mkDerivation {
   homepage = "https://github.com/well-typed/cborg";
   description = "A library for encoding JSON as CBOR";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/cborg.nix b/pkgs/cborg.nix
index 0fb456b312e753bbd2f75bae6d0659a1985952c7..9f508ba2f7180c1672b5ab1e0f33e0122ee8de1f 100644
--- a/pkgs/cborg.nix
+++ b/pkgs/cborg.nix
@@ -1,20 +1,61 @@
-{ mkDerivation, aeson, array, base, base-orphans, base16-bytestring
-, base64-bytestring, bytestring, containers, deepseq, ghc-bignum
-, ghc-prim, half, lib, primitive, QuickCheck, random, scientific
-, tasty, tasty-hunit, tasty-quickcheck, text, vector
+{ mkDerivation
+, aeson
+, array
+, base
+, base-orphans
+, base16-bytestring
+, base64-bytestring
+, bytestring
+, containers
+, deepseq
+, ghc-bignum
+, ghc-prim
+, half
+, lib
+, primitive
+, QuickCheck
+, random
+, scientific
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, text
+, vector
 }:
 mkDerivation {
   pname = "cborg";
   version = "0.2.8.0";
   sha256 = "2e59c827c273b57af0fcbbfb62f6d15faeb399e0d89d57baf8adcc60e62ab01e";
   libraryHaskellDepends = [
-    array base bytestring containers deepseq ghc-bignum ghc-prim half
-    primitive text
+    array
+    base
+    bytestring
+    containers
+    deepseq
+    ghc-bignum
+    ghc-prim
+    half
+    primitive
+    text
   ];
   testHaskellDepends = [
-    aeson array base base-orphans base16-bytestring base64-bytestring
-    bytestring deepseq half QuickCheck random scientific tasty
-    tasty-hunit tasty-quickcheck text vector
+    aeson
+    array
+    base
+    base-orphans
+    base16-bytestring
+    base64-bytestring
+    bytestring
+    deepseq
+    half
+    QuickCheck
+    random
+    scientific
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    text
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -22,4 +63,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Concise Binary Object Representation (CBOR)";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/cereal.nix b/pkgs/cereal.nix
index 93418fdb5ba30b9d6cd56195d4506d8733ed3c30..bcc990342c87b278236a4a3b250b0c1287c86651 100644
--- a/pkgs/cereal.nix
+++ b/pkgs/cereal.nix
@@ -1,15 +1,30 @@
-{ mkDerivation, array, base, bytestring, containers, ghc-prim, lib
-, QuickCheck, test-framework, test-framework-quickcheck2
+{ mkDerivation
+, array
+, base
+, bytestring
+, containers
+, ghc-prim
+, lib
+, QuickCheck
+, test-framework
+, test-framework-quickcheck2
 }:
 mkDerivation {
   pname = "cereal";
   version = "0.5.8.3";
   sha256 = "99905220661b26e5bd91130bd9772554938608a5b1d717240a6eb331121e0f6a";
   libraryHaskellDepends = [
-    array base bytestring containers ghc-prim
+    array
+    base
+    bytestring
+    containers
+    ghc-prim
   ];
   testHaskellDepends = [
-    base bytestring QuickCheck test-framework
+    base
+    bytestring
+    QuickCheck
+    test-framework
     test-framework-quickcheck2
   ];
   doHaddock = false;
@@ -19,4 +34,4 @@ mkDerivation {
   homepage = "https://github.com/GaloisInc/cereal";
   description = "A binary serialization library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/citeproc.nix b/pkgs/citeproc.nix
index e83777bd7fc993fc269d2615844f9fed62547291..a0b4ab88aa687e42c31a2c225e32ef206902d638 100644
--- a/pkgs/citeproc.nix
+++ b/pkgs/citeproc.nix
@@ -1,8 +1,28 @@
-{ mkDerivation, aeson, attoparsec, base, bytestring
-, case-insensitive, containers, data-default, Diff, directory
-, file-embed, filepath, lib, mtl, pandoc-types, pretty, safe
-, scientific, text, timeit, transformers, unicode-collation
-, uniplate, vector, xml-conduit
+{ mkDerivation
+, aeson
+, attoparsec
+, base
+, bytestring
+, case-insensitive
+, containers
+, data-default
+, Diff
+, directory
+, file-embed
+, filepath
+, lib
+, mtl
+, pandoc-types
+, pretty
+, safe
+, scientific
+, text
+, timeit
+, transformers
+, unicode-collation
+, uniplate
+, vector
+, xml-conduit
 }:
 mkDerivation {
   pname = "citeproc";
@@ -11,13 +31,38 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    aeson attoparsec base bytestring case-insensitive containers
-    data-default file-embed filepath pandoc-types safe scientific text
-    transformers unicode-collation uniplate vector xml-conduit
+    aeson
+    attoparsec
+    base
+    bytestring
+    case-insensitive
+    containers
+    data-default
+    file-embed
+    filepath
+    pandoc-types
+    safe
+    scientific
+    text
+    transformers
+    unicode-collation
+    uniplate
+    vector
+    xml-conduit
   ];
   testHaskellDepends = [
-    aeson base bytestring containers Diff directory filepath mtl pretty
-    text timeit transformers
+    aeson
+    base
+    bytestring
+    containers
+    Diff
+    directory
+    filepath
+    mtl
+    pretty
+    text
+    timeit
+    transformers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -25,4 +70,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Generates citations and bibliography from CSL styles";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+}
diff --git a/pkgs/co-log-core.nix b/pkgs/co-log-core.nix
index f531917bdab8943ad838ab5718cf068427ad6e8a..e39a227e8eedfcaa15b997581b5a1ea3a12d5fd0 100644
--- a/pkgs/co-log-core.nix
+++ b/pkgs/co-log-core.nix
@@ -12,4 +12,4 @@ mkDerivation {
   homepage = "https://github.com/co-log/co-log-core";
   description = "Composable Contravariant Comonadic Logging Library";
   license = lib.licenses.mpl20;
-}
\ No newline at end of file
+}
diff --git a/pkgs/comonad.nix b/pkgs/comonad.nix
index 38c51fd96ceab9ff9cda7de685606a95f74b58a1..b26e36ba11097d5c59f3a869bb693813051edbc8 100644
--- a/pkgs/comonad.nix
+++ b/pkgs/comonad.nix
@@ -1,5 +1,12 @@
-{ mkDerivation, base, containers, distributive, indexed-traversable
-, lib, tagged, transformers, transformers-compat
+{ mkDerivation
+, base
+, containers
+, distributive
+, indexed-traversable
+, lib
+, tagged
+, transformers
+, transformers-compat
 }:
 mkDerivation {
   pname = "comonad";
@@ -8,8 +15,13 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "0zlgkcd61cwsdbgjz03pfbjxhj6dc25792h7rwh0zy677vbsn6hz";
   libraryHaskellDepends = [
-    base containers distributive indexed-traversable tagged
-    transformers transformers-compat
+    base
+    containers
+    distributive
+    indexed-traversable
+    tagged
+    transformers
+    transformers-compat
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +30,4 @@ mkDerivation {
   homepage = "http://github.com/ekmett/comonad/";
   description = "Comonads";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/compact.nix b/pkgs/compact.nix
index 72ea2cefb013c79c151266932399127605466717..bac9585bb9e5e67c554584a5ff1db293d681deb3 100644
--- a/pkgs/compact.nix
+++ b/pkgs/compact.nix
@@ -1,4 +1,9 @@
-{ mkDerivation, base, binary, bytestring, directory, ghc-compact
+{ mkDerivation
+, base
+, binary
+, bytestring
+, directory
+, ghc-compact
 , lib
 }:
 mkDerivation {
@@ -16,4 +21,4 @@ mkDerivation {
   homepage = "https://github.com/ezyang/compact";
   description = "Non-GC'd, contiguous storage for immutable data structures";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/compactable.nix b/pkgs/compactable.nix
index 391b79c9472fe90eb5e9a16f2bf5372497f1cb86..d632014a1a01e5aa555b8d98756521dfaaafc2a5 100644
--- a/pkgs/compactable.nix
+++ b/pkgs/compactable.nix
@@ -1,8 +1,27 @@
-{ mkDerivation, aeson, base, base-compat, bifunctors, containers
-, contravariant, data-default-class, deepseq, genvalidity
-, genvalidity-sydtest, hashable, keys, lens, lib, QuickCheck
-, semigroupoids, sydtest, sydtest-discover, these, transformers
-, transformers-compat, unordered-containers, vector
+{ mkDerivation
+, aeson
+, base
+, base-compat
+, bifunctors
+, containers
+, contravariant
+, data-default-class
+, deepseq
+, genvalidity
+, genvalidity-sydtest
+, hashable
+, keys
+, lens
+, lib
+, QuickCheck
+, semigroupoids
+, sydtest
+, sydtest-discover
+, these
+, transformers
+, transformers-compat
+, unordered-containers
+, vector
 , vector-instances
 }:
 mkDerivation {
@@ -10,14 +29,36 @@ mkDerivation {
   version = "0.2.0.0";
   sha256 = "871c6e5a6d0b9a27624a3393a0b048358cf9289b8e35535bb11c469f56cdec59";
   libraryHaskellDepends = [
-    aeson base base-compat bifunctors containers contravariant
-    data-default-class deepseq hashable keys lens QuickCheck
-    semigroupoids these transformers transformers-compat
-    unordered-containers vector vector-instances
+    aeson
+    base
+    base-compat
+    bifunctors
+    containers
+    contravariant
+    data-default-class
+    deepseq
+    hashable
+    keys
+    lens
+    QuickCheck
+    semigroupoids
+    these
+    transformers
+    transformers-compat
+    unordered-containers
+    vector
+    vector-instances
   ];
   testHaskellDepends = [
-    base containers genvalidity genvalidity-sydtest QuickCheck sydtest
-    sydtest-discover these vector
+    base
+    containers
+    genvalidity
+    genvalidity-sydtest
+    QuickCheck
+    sydtest
+    sydtest-discover
+    these
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -25,4 +66,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "A typeclass for structures which can be catMaybed, filtered, and partitioned";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/composite-base.nix b/pkgs/composite-base.nix
index a61c81704ad265ebf41fdc0f039d804ab0d0c788..b1512872654a1cb9d0d1db9d246d9019f5e960bd 100644
--- a/pkgs/composite-base.nix
+++ b/pkgs/composite-base.nix
@@ -1,20 +1,56 @@
-{ mkDerivation, base, deepseq, exceptions, hspec, lens, lib
-, monad-control, mtl, profunctors, QuickCheck, template-haskell
-, text, transformers, transformers-base, unliftio-core, vinyl
+{ mkDerivation
+, base
+, deepseq
+, exceptions
+, hspec
+, lens
+, lib
+, monad-control
+, mtl
+, profunctors
+, QuickCheck
+, template-haskell
+, text
+, transformers
+, transformers-base
+, unliftio-core
+, vinyl
 }:
 mkDerivation {
   pname = "composite-base";
   version = "0.8.1.0";
   sha256 = "a8de050a65b8d3febfd48ea0d7b9bb215c8473b7dda7760d7c2df279a92258a3";
   libraryHaskellDepends = [
-    base deepseq exceptions lens monad-control mtl profunctors
-    template-haskell text transformers transformers-base unliftio-core
+    base
+    deepseq
+    exceptions
+    lens
+    monad-control
+    mtl
+    profunctors
+    template-haskell
+    text
+    transformers
+    transformers-base
+    unliftio-core
     vinyl
   ];
   testHaskellDepends = [
-    base deepseq exceptions hspec lens monad-control mtl profunctors
-    QuickCheck template-haskell text transformers transformers-base
-    unliftio-core vinyl
+    base
+    deepseq
+    exceptions
+    hspec
+    lens
+    monad-control
+    mtl
+    profunctors
+    QuickCheck
+    template-haskell
+    text
+    transformers
+    transformers-base
+    unliftio-core
+    vinyl
   ];
   doHaddock = false;
   jailbreak = true;
@@ -23,4 +59,4 @@ mkDerivation {
   homepage = "https://github.com/composite-hs/composite-base#readme";
   description = "Shared utilities for composite-* packages";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/composite-cassava.nix b/pkgs/composite-cassava.nix
index 6d667f8e269f78b885b463613da7f9c3a544ab4f..508ae206415ff1eb3e56828ae57fb17fec67e028 100644
--- a/pkgs/composite-cassava.nix
+++ b/pkgs/composite-cassava.nix
@@ -1,16 +1,37 @@
-{ mkDerivation, base, bytestring, cassava, composite-base, lib
-, tasty, tasty-hunit, text, unordered-containers, vector
+{ mkDerivation
+, base
+, bytestring
+, cassava
+, composite-base
+, lib
+, tasty
+, tasty-hunit
+, text
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "composite-cassava";
   version = "0.0.3.1";
   sha256 = "aa776b23dcf8ad3833159777eb5e0230dd2681527d7089fd072a618cca791e8d";
   libraryHaskellDepends = [
-    base cassava composite-base text unordered-containers vector
+    base
+    cassava
+    composite-base
+    text
+    unordered-containers
+    vector
   ];
   testHaskellDepends = [
-    base bytestring cassava composite-base tasty tasty-hunit text
-    unordered-containers vector
+    base
+    bytestring
+    cassava
+    composite-base
+    tasty
+    tasty-hunit
+    text
+    unordered-containers
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +39,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Csv parsing functionality for composite";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/composite-dhall.nix b/pkgs/composite-dhall.nix
index e6aaf86ed0e5d82f0550fcb70b2051bf3672c54d..331ff31eace8690d07c6bebe81225704e3d7fab9 100644
--- a/pkgs/composite-dhall.nix
+++ b/pkgs/composite-dhall.nix
@@ -1,5 +1,12 @@
-{ mkDerivation, base, composite-base, dhall, lib, tasty
-, tasty-hunit, text, vinyl
+{ mkDerivation
+, base
+, composite-base
+, dhall
+, lib
+, tasty
+, tasty-hunit
+, text
+, vinyl
 }:
 mkDerivation {
   pname = "composite-dhall";
@@ -7,7 +14,13 @@ mkDerivation {
   sha256 = "aa6c8a8a05c5aa5cc7c76440f57f9459f7f3aa07b1f4b290549a17c196c2eb34";
   libraryHaskellDepends = [ base composite-base dhall text vinyl ];
   testHaskellDepends = [
-    base composite-base dhall tasty tasty-hunit text vinyl
+    base
+    composite-base
+    dhall
+    tasty
+    tasty-hunit
+    text
+    vinyl
   ];
   doHaddock = false;
   jailbreak = true;
@@ -15,4 +28,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Dhall instances for composite records";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/composite-lens-extra.nix b/pkgs/composite-lens-extra.nix
index f8339f4df5a86187a43050c85cc8b8b55cada45f..61327548013fe2743937b18496e7864d523605e1 100644
--- a/pkgs/composite-lens-extra.nix
+++ b/pkgs/composite-lens-extra.nix
@@ -10,4 +10,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Extra lens functions for composite";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/composite-tuple.nix b/pkgs/composite-tuple.nix
index ed47ed1f31950b389acc0cca785734878fd07a22..0f51d1cff3e091feeafe00e260ffd038645d4835 100644
--- a/pkgs/composite-tuple.nix
+++ b/pkgs/composite-tuple.nix
@@ -12,4 +12,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Tuple functions for composite records";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/conduit-extra.nix b/pkgs/conduit-extra.nix
index ca4ed40c7a08e9b9df7717fba87f65cd63eab5d3..924aeb8ce684402b4e8be1bbad75509d66c2e762 100644
--- a/pkgs/conduit-extra.nix
+++ b/pkgs/conduit-extra.nix
@@ -1,26 +1,78 @@
-{ mkDerivation, async, attoparsec, base, bytestring, conduit
-, directory, exceptions, filepath, gauge, hspec, hspec-discover
-, lib, network, primitive, process, QuickCheck, resourcet, stm
-, streaming-commons, text, transformers, transformers-base
-, typed-process, unliftio-core
+{ mkDerivation
+, async
+, attoparsec
+, base
+, bytestring
+, conduit
+, directory
+, exceptions
+, filepath
+, gauge
+, hspec
+, hspec-discover
+, lib
+, network
+, primitive
+, process
+, QuickCheck
+, resourcet
+, stm
+, streaming-commons
+, text
+, transformers
+, transformers-base
+, typed-process
+, unliftio-core
 }:
 mkDerivation {
   pname = "conduit-extra";
   version = "1.3.6";
   sha256 = "8950c38049d892c38590d389bed49ecf880671f58ec63dd4709d9fe3d4b8f153";
   libraryHaskellDepends = [
-    async attoparsec base bytestring conduit directory filepath network
-    primitive process resourcet stm streaming-commons text transformers
-    typed-process unliftio-core
+    async
+    attoparsec
+    base
+    bytestring
+    conduit
+    directory
+    filepath
+    network
+    primitive
+    process
+    resourcet
+    stm
+    streaming-commons
+    text
+    transformers
+    typed-process
+    unliftio-core
   ];
   testHaskellDepends = [
-    async attoparsec base bytestring conduit directory exceptions
-    filepath hspec process QuickCheck resourcet stm streaming-commons
-    text transformers transformers-base
+    async
+    attoparsec
+    base
+    bytestring
+    conduit
+    directory
+    exceptions
+    filepath
+    hspec
+    process
+    QuickCheck
+    resourcet
+    stm
+    streaming-commons
+    text
+    transformers
+    transformers-base
   ];
   testToolDepends = [ hspec-discover ];
   benchmarkHaskellDepends = [
-    base bytestring conduit gauge transformers
+    base
+    bytestring
+    conduit
+    gauge
+    transformers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -29,4 +81,4 @@ mkDerivation {
   homepage = "http://github.com/snoyberg/conduit";
   description = "Batteries included conduit: adapters for common libraries";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/conduit.nix b/pkgs/conduit.nix
index d0466c0abaf840349caf3e320740a1e32e5db33a..b4459b91ea7534784e1e6a37b6421289ea0e3921 100644
--- a/pkgs/conduit.nix
+++ b/pkgs/conduit.nix
@@ -1,25 +1,81 @@
-{ mkDerivation, base, bytestring, containers, deepseq, directory
-, exceptions, filepath, gauge, hspec, kan-extensions, lib
-, mono-traversable, mtl, mwc-random, primitive, QuickCheck
-, resourcet, safe, silently, split, text, transformers, unix
-, unliftio, unliftio-core, vector
+{ mkDerivation
+, base
+, bytestring
+, containers
+, deepseq
+, directory
+, exceptions
+, filepath
+, gauge
+, hspec
+, kan-extensions
+, lib
+, mono-traversable
+, mtl
+, mwc-random
+, primitive
+, QuickCheck
+, resourcet
+, safe
+, silently
+, split
+, text
+, transformers
+, unix
+, unliftio
+, unliftio-core
+, vector
 }:
 mkDerivation {
   pname = "conduit";
   version = "1.3.4.2";
   sha256 = "2cb9832f27c7cd50daed1309f688afc4da1bd49697cbeda8ec3f81ab0bcf2197";
   libraryHaskellDepends = [
-    base bytestring directory exceptions filepath mono-traversable mtl
-    primitive resourcet text transformers unix unliftio-core vector
+    base
+    bytestring
+    directory
+    exceptions
+    filepath
+    mono-traversable
+    mtl
+    primitive
+    resourcet
+    text
+    transformers
+    unix
+    unliftio-core
+    vector
   ];
   testHaskellDepends = [
-    base bytestring containers directory exceptions filepath hspec
-    mono-traversable mtl QuickCheck resourcet safe silently split text
-    transformers unliftio vector
+    base
+    bytestring
+    containers
+    directory
+    exceptions
+    filepath
+    hspec
+    mono-traversable
+    mtl
+    QuickCheck
+    resourcet
+    safe
+    silently
+    split
+    text
+    transformers
+    unliftio
+    vector
   ];
   benchmarkHaskellDepends = [
-    base containers deepseq gauge hspec kan-extensions mwc-random
-    transformers vector
+    base
+    containers
+    deepseq
+    gauge
+    hspec
+    kan-extensions
+    mwc-random
+    transformers
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -28,4 +84,4 @@ mkDerivation {
   homepage = "http://github.com/snoyberg/conduit";
   description = "Streaming data processing library";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/config-ini.nix b/pkgs/config-ini.nix
index a21e0692e3b80090456ca1de1c3e48ef158a607e..a9f1909358db064a5b1f03f390b5ed7b4346483c 100644
--- a/pkgs/config-ini.nix
+++ b/pkgs/config-ini.nix
@@ -1,15 +1,35 @@
-{ mkDerivation, base, containers, directory, hedgehog, ini, lib
-, megaparsec, text, transformers, unordered-containers
+{ mkDerivation
+, base
+, containers
+, directory
+, hedgehog
+, ini
+, lib
+, megaparsec
+, text
+, transformers
+, unordered-containers
 }:
 mkDerivation {
   pname = "config-ini";
   version = "0.2.5.0";
   sha256 = "6f7ce53c22392b5b41e3c0a9853e4183c3bbcb18010f9630f48a90f69bbf6f1f";
   libraryHaskellDepends = [
-    base containers megaparsec text transformers unordered-containers
+    base
+    containers
+    megaparsec
+    text
+    transformers
+    unordered-containers
   ];
   testHaskellDepends = [
-    base containers directory hedgehog ini text unordered-containers
+    base
+    containers
+    directory
+    hedgehog
+    ini
+    text
+    unordered-containers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +38,4 @@ mkDerivation {
   homepage = "https://github.com/aisamanra/config-ini";
   description = "A library for simple INI-based configuration files";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/constraints.nix b/pkgs/constraints.nix
index 1b7d3ebf4c5d48428269330100329e2136573873..07598782bb65b51bb130746d4c84e147a5848b5c 100644
--- a/pkgs/constraints.nix
+++ b/pkgs/constraints.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, base, binary, deepseq, ghc-prim, hashable, hspec
-, hspec-discover, lib, mtl, transformers, transformers-compat
+{ mkDerivation
+, base
+, binary
+, deepseq
+, ghc-prim
+, hashable
+, hspec
+, hspec-discover
+, lib
+, mtl
+, transformers
+, transformers-compat
 , type-equality
 }:
 mkDerivation {
@@ -7,8 +17,15 @@ mkDerivation {
   version = "0.13.4";
   sha256 = "4186946df4b88c5d7cae3a42aa426f30fd5d249835ea1d290e139cebbf464434";
   libraryHaskellDepends = [
-    base binary deepseq ghc-prim hashable mtl transformers
-    transformers-compat type-equality
+    base
+    binary
+    deepseq
+    ghc-prim
+    hashable
+    mtl
+    transformers
+    transformers-compat
+    type-equality
   ];
   testHaskellDepends = [ base hspec ];
   testToolDepends = [ hspec-discover ];
@@ -19,4 +36,4 @@ mkDerivation {
   homepage = "http://github.com/ekmett/constraints/";
   description = "Constraint manipulation";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+}
diff --git a/pkgs/cryptohash-sha1.nix b/pkgs/cryptohash-sha1.nix
index 5115814074ba6bed0fbb44399fa57a745ce1c336..9637e672a8d4b67852253291579ccb2551a7c069 100644
--- a/pkgs/cryptohash-sha1.nix
+++ b/pkgs/cryptohash-sha1.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, base, base16-bytestring, bytestring, criterion, lib
-, SHA, tasty, tasty-hunit, tasty-quickcheck
+{ mkDerivation
+, base
+, base16-bytestring
+, bytestring
+, criterion
+, lib
+, SHA
+, tasty
+, tasty-hunit
+, tasty-quickcheck
 }:
 mkDerivation {
   pname = "cryptohash-sha1";
@@ -9,7 +17,12 @@ mkDerivation {
   editedCabalFile = "0bz9rfl7b2iwn45m0lxcmsyi5rrv3xdgzx2lzr79bds91dw6i25b";
   libraryHaskellDepends = [ base bytestring ];
   testHaskellDepends = [
-    base base16-bytestring bytestring SHA tasty tasty-hunit
+    base
+    base16-bytestring
+    bytestring
+    SHA
+    tasty
+    tasty-hunit
     tasty-quickcheck
   ];
   benchmarkHaskellDepends = [ base bytestring criterion ];
@@ -20,4 +33,4 @@ mkDerivation {
   homepage = "https://github.com/hvr/cryptohash-sha1";
   description = "Fast, pure and practical SHA-1 implementation";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/cryptonite.nix b/pkgs/cryptonite.nix
index 7003204e397ab036db59404373485515947aac49..e6660effa51fa9864e9880dae4161db55669c651 100644
--- a/pkgs/cryptonite.nix
+++ b/pkgs/cryptonite.nix
@@ -1,19 +1,48 @@
-{ mkDerivation, base, basement, bytestring, deepseq, gauge
-, ghc-prim, integer-gmp, lib, memory, random, tasty, tasty-hunit
-, tasty-kat, tasty-quickcheck
+{ mkDerivation
+, base
+, basement
+, bytestring
+, deepseq
+, gauge
+, ghc-prim
+, integer-gmp
+, lib
+, memory
+, random
+, tasty
+, tasty-hunit
+, tasty-kat
+, tasty-quickcheck
 }:
 mkDerivation {
   pname = "cryptonite";
   version = "0.30";
   sha256 = "56099c8a8aa01d2ee914b670c97c1f818186dbb886e2025b73d9c2afe3496b1d";
   libraryHaskellDepends = [
-    base basement bytestring deepseq ghc-prim integer-gmp memory
+    base
+    basement
+    bytestring
+    deepseq
+    ghc-prim
+    integer-gmp
+    memory
   ];
   testHaskellDepends = [
-    base bytestring memory tasty tasty-hunit tasty-kat tasty-quickcheck
+    base
+    bytestring
+    memory
+    tasty
+    tasty-hunit
+    tasty-kat
+    tasty-quickcheck
   ];
   benchmarkHaskellDepends = [
-    base bytestring deepseq gauge memory random
+    base
+    bytestring
+    deepseq
+    gauge
+    memory
+    random
   ];
   doHaddock = false;
   jailbreak = true;
@@ -22,4 +51,4 @@ mkDerivation {
   homepage = "https://github.com/haskell-crypto/cryptonite";
   description = "Cryptography Primitives sink";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/data-fix.nix b/pkgs/data-fix.nix
index 0f09c1c6fd613823ffc1fa990a737c7b5bdf4c28..61d17d73b6319cbe281aacf46f95adca155fe68c 100644
--- a/pkgs/data-fix.nix
+++ b/pkgs/data-fix.nix
@@ -13,4 +13,4 @@ mkDerivation {
   homepage = "https://github.com/spell-music/data-fix";
   description = "Fixpoint data types";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/dec.nix b/pkgs/dec.nix
index 6383f7a2c6631ca5d3212fb63e7bd41d03aba073..d44d4289e5e4478bf4badefc028f66b261ff8520 100644
--- a/pkgs/dec.nix
+++ b/pkgs/dec.nix
@@ -11,4 +11,4 @@ mkDerivation {
   homepage = "https://github.com/phadej/vec";
   description = "Decidable propositions";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/dhall.nix b/pkgs/dhall.nix
index 9c29f8f718ebeb3c28338818177385cf40edb961..fe73f8c6a62560f5bf7b46449ba914ef919c5d9a 100644
--- a/pkgs/dhall.nix
+++ b/pkgs/dhall.nix
@@ -1,19 +1,75 @@
-{ mkDerivation, aeson, aeson-pretty, ansi-terminal, atomic-write
-, base, base16-bytestring, bytestring, case-insensitive, cborg
-, cborg-json, containers, contravariant, cryptohash-sha256
-, data-fix, deepseq, Diff, directory, doctest, dotgen, either
-, exceptions, filepath, foldl, gauge, generic-random, half
-, hashable, haskeline, http-client, http-client-tls, http-types
-, indexed-traversable, lens-family-core, lib, megaparsec, mmorph
-, mockery, mtl, network-uri, optparse-applicative
-, parser-combinators, parsers, pretty-simple, prettyprinter
-, prettyprinter-ansi-terminal, profunctors, QuickCheck
-, quickcheck-instances, repline, scientific, serialise
-, special-values, spoon, system-filepath, tasty
-, tasty-expected-failure, tasty-hunit, tasty-quickcheck
-, tasty-silver, template-haskell, temporary, text, text-manipulate
-, text-short, th-lift-instances, time, transformers, turtle
-, unordered-containers, uri-encode, vector
+{ mkDerivation
+, aeson
+, aeson-pretty
+, ansi-terminal
+, atomic-write
+, base
+, base16-bytestring
+, bytestring
+, case-insensitive
+, cborg
+, cborg-json
+, containers
+, contravariant
+, cryptohash-sha256
+, data-fix
+, deepseq
+, Diff
+, directory
+, doctest
+, dotgen
+, either
+, exceptions
+, filepath
+, foldl
+, gauge
+, generic-random
+, half
+, hashable
+, haskeline
+, http-client
+, http-client-tls
+, http-types
+, indexed-traversable
+, lens-family-core
+, lib
+, megaparsec
+, mmorph
+, mockery
+, mtl
+, network-uri
+, optparse-applicative
+, parser-combinators
+, parsers
+, pretty-simple
+, prettyprinter
+, prettyprinter-ansi-terminal
+, profunctors
+, QuickCheck
+, quickcheck-instances
+, repline
+, scientific
+, serialise
+, special-values
+, spoon
+, system-filepath
+, tasty
+, tasty-expected-failure
+, tasty-hunit
+, tasty-quickcheck
+, tasty-silver
+, template-haskell
+, temporary
+, text
+, text-manipulate
+, text-short
+, th-lift-instances
+, time
+, transformers
+, turtle
+, unordered-containers
+, uri-encode
+, vector
 }:
 mkDerivation {
   pname = "dhall";
@@ -25,56 +81,231 @@ mkDerivation {
   isExecutable = true;
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
-    aeson aeson-pretty ansi-terminal atomic-write base
-    base16-bytestring bytestring case-insensitive cborg cborg-json
-    containers contravariant cryptohash-sha256 data-fix deepseq Diff
-    directory dotgen either exceptions filepath half hashable haskeline
-    http-client http-client-tls http-types indexed-traversable
-    lens-family-core megaparsec mmorph mtl network-uri
-    optparse-applicative parser-combinators parsers pretty-simple
-    prettyprinter prettyprinter-ansi-terminal profunctors repline
-    scientific serialise template-haskell text text-manipulate
-    text-short th-lift-instances time transformers unordered-containers
-    uri-encode vector
+    aeson
+    aeson-pretty
+    ansi-terminal
+    atomic-write
+    base
+    base16-bytestring
+    bytestring
+    case-insensitive
+    cborg
+    cborg-json
+    containers
+    contravariant
+    cryptohash-sha256
+    data-fix
+    deepseq
+    Diff
+    directory
+    dotgen
+    either
+    exceptions
+    filepath
+    half
+    hashable
+    haskeline
+    http-client
+    http-client-tls
+    http-types
+    indexed-traversable
+    lens-family-core
+    megaparsec
+    mmorph
+    mtl
+    network-uri
+    optparse-applicative
+    parser-combinators
+    parsers
+    pretty-simple
+    prettyprinter
+    prettyprinter-ansi-terminal
+    profunctors
+    repline
+    scientific
+    serialise
+    template-haskell
+    text
+    text-manipulate
+    text-short
+    th-lift-instances
+    time
+    transformers
+    unordered-containers
+    uri-encode
+    vector
   ];
   executableHaskellDepends = [
-    aeson aeson-pretty ansi-terminal atomic-write base
-    base16-bytestring bytestring case-insensitive cborg cborg-json
-    containers contravariant data-fix deepseq Diff directory dotgen
-    either exceptions filepath half hashable haskeline
-    indexed-traversable lens-family-core megaparsec mmorph mtl
-    network-uri optparse-applicative parser-combinators parsers
-    pretty-simple prettyprinter prettyprinter-ansi-terminal profunctors
-    repline scientific serialise template-haskell text text-manipulate
-    text-short th-lift-instances time transformers unordered-containers
-    uri-encode vector
+    aeson
+    aeson-pretty
+    ansi-terminal
+    atomic-write
+    base
+    base16-bytestring
+    bytestring
+    case-insensitive
+    cborg
+    cborg-json
+    containers
+    contravariant
+    data-fix
+    deepseq
+    Diff
+    directory
+    dotgen
+    either
+    exceptions
+    filepath
+    half
+    hashable
+    haskeline
+    indexed-traversable
+    lens-family-core
+    megaparsec
+    mmorph
+    mtl
+    network-uri
+    optparse-applicative
+    parser-combinators
+    parsers
+    pretty-simple
+    prettyprinter
+    prettyprinter-ansi-terminal
+    profunctors
+    repline
+    scientific
+    serialise
+    template-haskell
+    text
+    text-manipulate
+    text-short
+    th-lift-instances
+    time
+    transformers
+    unordered-containers
+    uri-encode
+    vector
   ];
   testHaskellDepends = [
-    aeson aeson-pretty ansi-terminal atomic-write base
-    base16-bytestring bytestring case-insensitive cborg cborg-json
-    containers contravariant data-fix deepseq Diff directory doctest
-    dotgen either exceptions filepath foldl generic-random half
-    hashable haskeline http-client http-client-tls indexed-traversable
-    lens-family-core megaparsec mmorph mockery mtl network-uri
-    optparse-applicative parser-combinators parsers pretty-simple
-    prettyprinter prettyprinter-ansi-terminal profunctors QuickCheck
-    quickcheck-instances repline scientific serialise special-values
-    spoon system-filepath tasty tasty-expected-failure tasty-hunit
-    tasty-quickcheck tasty-silver template-haskell temporary text
-    text-manipulate text-short th-lift-instances time transformers
-    turtle unordered-containers uri-encode vector
+    aeson
+    aeson-pretty
+    ansi-terminal
+    atomic-write
+    base
+    base16-bytestring
+    bytestring
+    case-insensitive
+    cborg
+    cborg-json
+    containers
+    contravariant
+    data-fix
+    deepseq
+    Diff
+    directory
+    doctest
+    dotgen
+    either
+    exceptions
+    filepath
+    foldl
+    generic-random
+    half
+    hashable
+    haskeline
+    http-client
+    http-client-tls
+    indexed-traversable
+    lens-family-core
+    megaparsec
+    mmorph
+    mockery
+    mtl
+    network-uri
+    optparse-applicative
+    parser-combinators
+    parsers
+    pretty-simple
+    prettyprinter
+    prettyprinter-ansi-terminal
+    profunctors
+    QuickCheck
+    quickcheck-instances
+    repline
+    scientific
+    serialise
+    special-values
+    spoon
+    system-filepath
+    tasty
+    tasty-expected-failure
+    tasty-hunit
+    tasty-quickcheck
+    tasty-silver
+    template-haskell
+    temporary
+    text
+    text-manipulate
+    text-short
+    th-lift-instances
+    time
+    transformers
+    turtle
+    unordered-containers
+    uri-encode
+    vector
   ];
   benchmarkHaskellDepends = [
-    aeson aeson-pretty ansi-terminal atomic-write base
-    base16-bytestring bytestring case-insensitive cborg cborg-json
-    containers contravariant data-fix deepseq Diff directory dotgen
-    either exceptions filepath gauge half hashable haskeline
-    indexed-traversable lens-family-core megaparsec mmorph mtl
-    network-uri optparse-applicative parser-combinators parsers
-    pretty-simple prettyprinter prettyprinter-ansi-terminal profunctors
-    repline scientific serialise template-haskell text text-manipulate
-    text-short th-lift-instances time transformers unordered-containers
-    uri-encode vector
+    aeson
+    aeson-pretty
+    ansi-terminal
+    atomic-write
+    base
+    base16-bytestring
+    bytestring
+    case-insensitive
+    cborg
+    cborg-json
+    containers
+    contravariant
+    data-fix
+    deepseq
+    Diff
+    directory
+    dotgen
+    either
+    exceptions
+    filepath
+    gauge
+    half
+    hashable
+    haskeline
+    indexed-traversable
+    lens-family-core
+    megaparsec
+    mmorph
+    mtl
+    network-uri
+    optparse-applicative
+    parser-combinators
+    parsers
+    pretty-simple
+    prettyprinter
+    prettyprinter-ansi-terminal
+    profunctors
+    repline
+    scientific
+    serialise
+    template-haskell
+    text
+    text-manipulate
+    text-short
+    th-lift-instances
+    time
+    transformers
+    unordered-containers
+    uri-encode
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -83,4 +314,4 @@ mkDerivation {
   description = "A configuration language guaranteed to terminate";
   license = lib.licenses.bsd3;
   mainProgram = "dhall";
-}
\ No newline at end of file
+}
diff --git a/pkgs/dimensional.nix b/pkgs/dimensional.nix
index 2cf3edaa05cf9bc19a7b40b1f8d9d26b52725a94..fbe1ad869f94ddc89957ade42c0a87d6f87e44db 100644
--- a/pkgs/dimensional.nix
+++ b/pkgs/dimensional.nix
@@ -1,16 +1,38 @@
-{ mkDerivation, base, criterion, deepseq, doctest, exact-pi, Glob
-, hspec, hspec-discover, ieee754, lib, numtype-dk, QuickCheck
-, template-haskell, vector
+{ mkDerivation
+, base
+, criterion
+, deepseq
+, doctest
+, exact-pi
+, Glob
+, hspec
+, hspec-discover
+, ieee754
+, lib
+, numtype-dk
+, QuickCheck
+, template-haskell
+, vector
 }:
 mkDerivation {
   pname = "dimensional";
   version = "1.5";
   sha256 = "da9ad59b8feebbc038f824bc960a099fc5ccc8cb1d234f12c230044be906a599";
   libraryHaskellDepends = [
-    base deepseq exact-pi ieee754 numtype-dk vector
+    base
+    deepseq
+    exact-pi
+    ieee754
+    numtype-dk
+    vector
   ];
   testHaskellDepends = [
-    base doctest Glob hspec QuickCheck template-haskell
+    base
+    doctest
+    Glob
+    hspec
+    QuickCheck
+    template-haskell
   ];
   testToolDepends = [ hspec-discover ];
   benchmarkHaskellDepends = [ base criterion deepseq ];
@@ -21,4 +43,4 @@ mkDerivation {
   homepage = "https://github.com/bjornbm/dimensional/";
   description = "Statically checked physical dimensions";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/doctest.nix b/pkgs/doctest.nix
index 476e90f6031723a6d900e676a4823d240b42ddc7..0375527273f29a85023892743a2d2c3b4599425f 100644
--- a/pkgs/doctest.nix
+++ b/pkgs/doctest.nix
@@ -1,7 +1,27 @@
-{ mkDerivation, base, base-compat, code-page, deepseq, directory
-, exceptions, fetchgit, filepath, ghc, ghc-paths, hspec, hspec-core
-, hspec-discover, HUnit, lib, mockery, process, QuickCheck, setenv
-, silently, stringbuilder, syb, transformers
+{ mkDerivation
+, base
+, base-compat
+, code-page
+, deepseq
+, directory
+, exceptions
+, fetchgit
+, filepath
+, ghc
+, ghc-paths
+, hspec
+, hspec-core
+, hspec-discover
+, HUnit
+, lib
+, mockery
+, process
+, QuickCheck
+, setenv
+, silently
+, stringbuilder
+, syb
+, transformers
 }:
 mkDerivation {
   pname = "doctest";
@@ -15,17 +35,54 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base base-compat code-page deepseq directory exceptions filepath
-    ghc ghc-paths process syb transformers
+    base
+    base-compat
+    code-page
+    deepseq
+    directory
+    exceptions
+    filepath
+    ghc
+    ghc-paths
+    process
+    syb
+    transformers
   ];
   executableHaskellDepends = [
-    base base-compat code-page deepseq directory exceptions filepath
-    ghc ghc-paths process syb transformers
+    base
+    base-compat
+    code-page
+    deepseq
+    directory
+    exceptions
+    filepath
+    ghc
+    ghc-paths
+    process
+    syb
+    transformers
   ];
   testHaskellDepends = [
-    base base-compat code-page deepseq directory exceptions filepath
-    ghc ghc-paths hspec hspec-core HUnit mockery process QuickCheck
-    setenv silently stringbuilder syb transformers
+    base
+    base-compat
+    code-page
+    deepseq
+    directory
+    exceptions
+    filepath
+    ghc
+    ghc-paths
+    hspec
+    hspec-core
+    HUnit
+    mockery
+    process
+    QuickCheck
+    setenv
+    silently
+    stringbuilder
+    syb
+    transformers
   ];
   testToolDepends = [ hspec-discover ];
   doHaddock = false;
@@ -36,4 +93,4 @@ mkDerivation {
   description = "Test interactive Haskell examples";
   license = lib.licenses.mit;
   mainProgram = "doctest";
-}
\ No newline at end of file
+}
diff --git a/pkgs/double-conversion.nix b/pkgs/double-conversion.nix
index 113e2987b590906f842bc2947e744ac076b5c1a9..5f889a133edea9b94d24a0821263598cd70f8313 100644
--- a/pkgs/double-conversion.nix
+++ b/pkgs/double-conversion.nix
@@ -1,6 +1,15 @@
-{ mkDerivation, base, bytestring, fetchgit, ghc-prim, HUnit, lib
-, system-cxx-std-lib, test-framework, test-framework-hunit
-, test-framework-quickcheck2, text
+{ mkDerivation
+, base
+, bytestring
+, fetchgit
+, ghc-prim
+, HUnit
+, lib
+, system-cxx-std-lib
+, test-framework
+, test-framework-hunit
+, test-framework-quickcheck2
+, text
 }:
 mkDerivation {
   pname = "double-conversion";
@@ -12,11 +21,20 @@ mkDerivation {
     fetchSubmodules = true;
   };
   libraryHaskellDepends = [
-    base bytestring ghc-prim system-cxx-std-lib text
+    base
+    bytestring
+    ghc-prim
+    system-cxx-std-lib
+    text
   ];
   testHaskellDepends = [
-    base bytestring HUnit test-framework test-framework-hunit
-    test-framework-quickcheck2 text
+    base
+    bytestring
+    HUnit
+    test-framework
+    test-framework-hunit
+    test-framework-quickcheck2
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -25,4 +43,4 @@ mkDerivation {
   homepage = "https://github.com/haskell/double-conversion";
   description = "Fast conversion between single and double precision floating point and text";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ed25519.nix b/pkgs/ed25519.nix
index 1b4c9c260bbe4e892a149b877202cad39881d3ca..978b4a71595bd8ab7c3f413c88c56e07ee343d48 100644
--- a/pkgs/ed25519.nix
+++ b/pkgs/ed25519.nix
@@ -1,5 +1,16 @@
-{ mkDerivation, base, bytestring, criterion, deepseq, directory
-, doctest, fetchgit, filepath, ghc-prim, hlint, lib, QuickCheck
+{ mkDerivation
+, base
+, bytestring
+, criterion
+, deepseq
+, directory
+, doctest
+, fetchgit
+, filepath
+, ghc-prim
+, hlint
+, lib
+, QuickCheck
 }:
 mkDerivation {
   pname = "ed25519";
@@ -12,7 +23,13 @@ mkDerivation {
   };
   libraryHaskellDepends = [ base bytestring ghc-prim ];
   testHaskellDepends = [
-    base bytestring directory doctest filepath hlint QuickCheck
+    base
+    bytestring
+    directory
+    doctest
+    filepath
+    hlint
+    QuickCheck
   ];
   benchmarkHaskellDepends = [ base bytestring criterion deepseq ];
   doHaddock = false;
@@ -22,4 +39,4 @@ mkDerivation {
   homepage = "http://thoughtpolice.github.com/hs-ed25519";
   description = "Ed25519 cryptographic signatures";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/effectful-cache.nix b/pkgs/effectful-cache.nix
index c76dc041d70cc87bb2f56cc99524f4e0541d1cff..df4587e3ddaa150bfe8f46605e40bb155da69e6e 100644
--- a/pkgs/effectful-cache.nix
+++ b/pkgs/effectful-cache.nix
@@ -1,5 +1,12 @@
-{ mkDerivation, base, cache, effectful-core, fetchgit, hashable
-, lib, tasty, tasty-hunit
+{ mkDerivation
+, base
+, cache
+, effectful-core
+, fetchgit
+, hashable
+, lib
+, tasty
+, tasty-hunit
 }:
 mkDerivation {
   pname = "effectful-cache";
@@ -12,7 +19,12 @@ mkDerivation {
   };
   libraryHaskellDepends = [ base cache effectful-core hashable ];
   testHaskellDepends = [
-    base cache effectful-core hashable tasty tasty-hunit
+    base
+    cache
+    effectful-core
+    hashable
+    tasty
+    tasty-hunit
   ];
   doHaddock = false;
   jailbreak = true;
@@ -20,4 +32,4 @@ mkDerivation {
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-effectful/effectful-cache/tree/main/effectful-cache#readme";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/effectful-core.nix b/pkgs/effectful-core.nix
index 30e9b5b46d91a7a25e19e20fb77344136cfd2428..de5471b2a09569627bf0b301c3c88376cd52ba0b 100644
--- a/pkgs/effectful-core.nix
+++ b/pkgs/effectful-core.nix
@@ -1,13 +1,25 @@
-{ mkDerivation, base, containers, exceptions, lib, monad-control
-, primitive, transformers-base, unliftio-core
+{ mkDerivation
+, base
+, containers
+, exceptions
+, lib
+, monad-control
+, primitive
+, transformers-base
+, unliftio-core
 }:
 mkDerivation {
   pname = "effectful-core";
   version = "2.1.0.0";
   sha256 = "93920bb5b58d6c92f51823c95e436a1a35c40fa677ee4f96014267698c43efd1";
   libraryHaskellDepends = [
-    base containers exceptions monad-control primitive
-    transformers-base unliftio-core
+    base
+    containers
+    exceptions
+    monad-control
+    primitive
+    transformers-base
+    unliftio-core
   ];
   doHaddock = false;
   jailbreak = true;
@@ -15,4 +27,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "An easy to use, performant extensible effects library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/effectful-th.nix b/pkgs/effectful-th.nix
index 4e4357b8590f2cc8be2626fccdcad6ad156c6cfe..65b61c5416a51a24318da8a2f3d545d346a160d8 100644
--- a/pkgs/effectful-th.nix
+++ b/pkgs/effectful-th.nix
@@ -1,5 +1,11 @@
-{ mkDerivation, base, containers, effectful, exceptions, lib
-, template-haskell, th-abstraction
+{ mkDerivation
+, base
+, containers
+, effectful
+, exceptions
+, lib
+, template-haskell
+, th-abstraction
 }:
 mkDerivation {
   pname = "effectful-th";
@@ -8,7 +14,11 @@ mkDerivation {
   revision = "3";
   editedCabalFile = "1nqwvgdvqgh4dvkidyaga7jd95p3hn54hy5gwadsvyf9lll4vjck";
   libraryHaskellDepends = [
-    base containers effectful exceptions template-haskell
+    base
+    containers
+    effectful
+    exceptions
+    template-haskell
     th-abstraction
   ];
   testHaskellDepends = [ base effectful ];
@@ -18,4 +28,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Template Haskell utilities for the effectful library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/effectful.nix b/pkgs/effectful.nix
index 3f6e367068a9a9a70dc2fb3627633503175af7d3..47c505f4361f799278fd643b95bd82c6d63fe63b 100644
--- a/pkgs/effectful.nix
+++ b/pkgs/effectful.nix
@@ -1,21 +1,55 @@
-{ mkDerivation, async, base, bytestring, containers, directory
-, effectful-core, exceptions, lib, lifted-base, process, stm, tasty
-, tasty-bench, tasty-hunit, text, time, unix, unliftio
+{ mkDerivation
+, async
+, base
+, bytestring
+, containers
+, directory
+, effectful-core
+, exceptions
+, lib
+, lifted-base
+, process
+, stm
+, tasty
+, tasty-bench
+, tasty-hunit
+, text
+, time
+, unix
+, unliftio
 }:
 mkDerivation {
   pname = "effectful";
   version = "2.1.0.0";
   sha256 = "76147d4d761d3267607a5f71c5925cbb2e8ae538aacaf6c6ddd9574eabec739b";
   libraryHaskellDepends = [
-    async base bytestring directory effectful-core process stm time
+    async
+    base
+    bytestring
+    directory
+    effectful-core
+    process
+    stm
+    time
     unliftio
   ];
   testHaskellDepends = [
-    base containers effectful-core exceptions lifted-base tasty
-    tasty-hunit unliftio
+    base
+    containers
+    effectful-core
+    exceptions
+    lifted-base
+    tasty
+    tasty-hunit
+    unliftio
   ];
   benchmarkHaskellDepends = [
-    async base tasty-bench text unix unliftio
+    async
+    base
+    tasty-bench
+    text
+    unix
+    unliftio
   ];
   doHaddock = false;
   jailbreak = true;
@@ -23,4 +57,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "An easy to use, performant extensible effects library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ema.nix b/pkgs/ema.nix
index f07bfa90b55d833961e46c2c383eda90a875a3bc..40f9ee99289da421e091c076a3789607cf2c117a 100644
--- a/pkgs/ema.nix
+++ b/pkgs/ema.nix
@@ -1,12 +1,47 @@
-{ mkDerivation, aeson, async, base, blaze-html, blaze-markup
-, constraints-extras, containers, data-default, dependent-sum
-, dependent-sum-template, directory, fetchgit, file-embed, filepath
-, filepattern, fsnotify, generic-optics, generics-sop, http-types
-, lib, lvar, monad-logger, monad-logger-extras, mtl
-, neat-interpolation, optics-core, optparse-applicative, pandoc
-, pandoc-types, raw-strings-qq, relude, sop-core, template-haskell
-, text, time, unionmount, unliftio, url-slug, wai
-, wai-middleware-static, wai-websockets, warp, websockets
+{ mkDerivation
+, aeson
+, async
+, base
+, blaze-html
+, blaze-markup
+, constraints-extras
+, containers
+, data-default
+, dependent-sum
+, dependent-sum-template
+, directory
+, fetchgit
+, file-embed
+, filepath
+, filepattern
+, fsnotify
+, generic-optics
+, generics-sop
+, http-types
+, lib
+, lvar
+, monad-logger
+, monad-logger-extras
+, mtl
+, neat-interpolation
+, optics-core
+, optparse-applicative
+, pandoc
+, pandoc-types
+, raw-strings-qq
+, relude
+, sop-core
+, template-haskell
+, text
+, time
+, unionmount
+, unliftio
+, url-slug
+, wai
+, wai-middleware-static
+, wai-websockets
+, warp
+, websockets
 }:
 mkDerivation {
   pname = "ema";
@@ -19,17 +54,54 @@ mkDerivation {
   };
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
-    aeson async base blaze-html blaze-markup constraints-extras
-    containers data-default dependent-sum dependent-sum-template
-    directory file-embed filepath filepattern fsnotify generic-optics
-    generics-sop http-types lvar monad-logger monad-logger-extras mtl
-    neat-interpolation optics-core optparse-applicative pandoc
-    pandoc-types relude sop-core template-haskell text time unionmount
-    unliftio url-slug wai wai-middleware-static wai-websockets warp
+    aeson
+    async
+    base
+    blaze-html
+    blaze-markup
+    constraints-extras
+    containers
+    data-default
+    dependent-sum
+    dependent-sum-template
+    directory
+    file-embed
+    filepath
+    filepattern
+    fsnotify
+    generic-optics
+    generics-sop
+    http-types
+    lvar
+    monad-logger
+    monad-logger-extras
+    mtl
+    neat-interpolation
+    optics-core
+    optparse-applicative
+    pandoc
+    pandoc-types
+    relude
+    sop-core
+    template-haskell
+    text
+    time
+    unionmount
+    unliftio
+    url-slug
+    wai
+    wai-middleware-static
+    wai-websockets
+    warp
     websockets
   ];
   testHaskellDepends = [
-    base generics-sop raw-strings-qq template-haskell text url-slug
+    base
+    generics-sop
+    raw-strings-qq
+    template-haskell
+    text
+    url-slug
   ];
   doHaddock = false;
   jailbreak = true;
@@ -38,4 +110,4 @@ mkDerivation {
   homepage = "https://ema.srid.ca/";
   description = "Static site generator library with hot reload";
   license = lib.licenses.agpl3Only;
-}
\ No newline at end of file
+}
diff --git a/pkgs/email-validate.nix b/pkgs/email-validate.nix
index ba6c1c700301a4e93400c22fd69f72fefef84bf0..05e17e100668b7c43936108667803c44955e625f 100644
--- a/pkgs/email-validate.nix
+++ b/pkgs/email-validate.nix
@@ -1,12 +1,22 @@
-{ mkDerivation, attoparsec, base, bytestring, doctest, hspec, lib
-, QuickCheck, template-haskell
+{ mkDerivation
+, attoparsec
+, base
+, bytestring
+, doctest
+, hspec
+, lib
+, QuickCheck
+, template-haskell
 }:
 mkDerivation {
   pname = "email-validate";
   version = "2.3.2.16";
   sha256 = "b8e5f155c1ba78ae25be88858b201d138cd1363519572edd9a13a9d086f023b3";
   libraryHaskellDepends = [
-    attoparsec base bytestring template-haskell
+    attoparsec
+    base
+    bytestring
+    template-haskell
   ];
   testHaskellDepends = [ base bytestring doctest hspec QuickCheck ];
   doHaddock = false;
@@ -16,4 +26,4 @@ mkDerivation {
   homepage = "https://github.com/Porges/email-validate-hs";
   description = "Email address validation";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/extra.nix b/pkgs/extra.nix
index 75d8a09f89c227d59fe3e32afe60f39e6ad4c02b..3147160cd9c08dd107c77f127ec9fd2bb0517bf0 100644
--- a/pkgs/extra.nix
+++ b/pkgs/extra.nix
@@ -1,15 +1,35 @@
-{ mkDerivation, base, clock, directory, filepath, lib, process
-, QuickCheck, quickcheck-instances, time, unix
+{ mkDerivation
+, base
+, clock
+, directory
+, filepath
+, lib
+, process
+, QuickCheck
+, quickcheck-instances
+, time
+, unix
 }:
 mkDerivation {
   pname = "extra";
   version = "1.7.12";
   sha256 = "e571a9ec1d8865f0fbb0e0ba1eb575f783b0365c80db19b54a93600bae43b03c";
   libraryHaskellDepends = [
-    base clock directory filepath process time unix
+    base
+    clock
+    directory
+    filepath
+    process
+    time
+    unix
   ];
   testHaskellDepends = [
-    base directory filepath QuickCheck quickcheck-instances unix
+    base
+    directory
+    filepath
+    QuickCheck
+    quickcheck-instances
+    unix
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +38,4 @@ mkDerivation {
   homepage = "https://github.com/ndmitchell/extra#readme";
   description = "Extra functions I use";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/fcf-containers.nix b/pkgs/fcf-containers.nix
index bf7f3674b0f9bd7f444ec3d081856f0b11eab29c..4eb346b79be39dc875648279bbbd3c325e917919 100644
--- a/pkgs/fcf-containers.nix
+++ b/pkgs/fcf-containers.nix
@@ -1,4 +1,9 @@
-{ mkDerivation, base, doctest, first-class-families, ghc-prim, lib
+{ mkDerivation
+, base
+, doctest
+, first-class-families
+, ghc-prim
+, lib
 , mtl
 }:
 mkDerivation {
@@ -10,7 +15,10 @@ mkDerivation {
   libraryHaskellDepends = [ base first-class-families ghc-prim mtl ];
   executableHaskellDepends = [ base first-class-families ];
   testHaskellDepends = [
-    base doctest first-class-families ghc-prim
+    base
+    doctest
+    first-class-families
+    ghc-prim
   ];
   doHaddock = false;
   jailbreak = true;
@@ -19,4 +27,4 @@ mkDerivation {
   homepage = "https://github.com/gspia/fcf-containers";
   description = "Data structures and algorithms for first-class-families";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/finite-field.nix b/pkgs/finite-field.nix
index 6fad6c1ed053f9fbf60843a18206c0691b177b00..b55e72960d47c31a99298469e790fe380a0556f0 100644
--- a/pkgs/finite-field.nix
+++ b/pkgs/finite-field.nix
@@ -1,17 +1,41 @@
-{ mkDerivation, base, containers, deepseq, hashable, lib, primes
-, QuickCheck, singletons, tasty, tasty-hunit, tasty-quickcheck
-, tasty-th, template-haskell
+{ mkDerivation
+, base
+, containers
+, deepseq
+, hashable
+, lib
+, primes
+, QuickCheck
+, singletons
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, tasty-th
+, template-haskell
 }:
 mkDerivation {
   pname = "finite-field";
   version = "0.10.0";
   sha256 = "b279ac001447da39cae504ecd3fc5efed43814fdf6f680c0d4a8afd7086882b3";
   libraryHaskellDepends = [
-    base deepseq hashable singletons template-haskell
+    base
+    deepseq
+    hashable
+    singletons
+    template-haskell
   ];
   testHaskellDepends = [
-    base containers deepseq hashable primes QuickCheck singletons tasty
-    tasty-hunit tasty-quickcheck tasty-th
+    base
+    containers
+    deepseq
+    hashable
+    primes
+    QuickCheck
+    singletons
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    tasty-th
   ];
   doHaddock = false;
   jailbreak = true;
@@ -19,4 +43,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Finite Fields";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/first-class-families.nix b/pkgs/first-class-families.nix
index f79eabe9d33d1330f37facee1094d2ba88d3ceb3..a32fb46570c275dac59072b4fa93a9c67a44c174 100644
--- a/pkgs/first-class-families.nix
+++ b/pkgs/first-class-families.nix
@@ -14,4 +14,4 @@ mkDerivation {
   homepage = "https://github.com/Lysxia/first-class-families#readme";
   description = "First-class type families";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/foldl.nix b/pkgs/foldl.nix
index b580fac2db90d2cfd4cf1aa79e901f05abcfca6a..73c72080e72851dd49b175cf9a591aac2cf8085b 100644
--- a/pkgs/foldl.nix
+++ b/pkgs/foldl.nix
@@ -1,7 +1,21 @@
-{ mkDerivation, base, bytestring, comonad, containers
-, contravariant, criterion, doctest, hashable, lib, primitive
-, profunctors, random, semigroupoids, text, transformers
-, unordered-containers, vector
+{ mkDerivation
+, base
+, bytestring
+, comonad
+, containers
+, contravariant
+, criterion
+, doctest
+, hashable
+, lib
+, primitive
+, profunctors
+, random
+, semigroupoids
+, text
+, transformers
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "foldl";
@@ -10,9 +24,20 @@ mkDerivation {
   revision = "5";
   editedCabalFile = "1b97k85zryid7x2ygi92ilv480ahfjn5yf1f4blllwyxn7zgvjv4";
   libraryHaskellDepends = [
-    base bytestring comonad containers contravariant hashable primitive
-    profunctors random semigroupoids text transformers
-    unordered-containers vector
+    base
+    bytestring
+    comonad
+    containers
+    contravariant
+    hashable
+    primitive
+    profunctors
+    random
+    semigroupoids
+    text
+    transformers
+    unordered-containers
+    vector
   ];
   testHaskellDepends = [ base doctest ];
   benchmarkHaskellDepends = [ base criterion ];
@@ -22,4 +47,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Composable, streaming, and efficient left folds";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/foundation.nix b/pkgs/foundation.nix
index 0451734ab8fe66c5aac34c1955438187d89f8b54..09f3a18d75b22b260ce713ede96fd261504d264e 100644
--- a/pkgs/foundation.nix
+++ b/pkgs/foundation.nix
@@ -13,4 +13,4 @@ mkDerivation {
   homepage = "https://github.com/haskell-foundation/foundation";
   description = "Alternative prelude with batteries and no dependencies";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/fourmolu.nix b/pkgs/fourmolu.nix
index cce0f3a21715a62d9ccb96bcb11ccf5c77e40d4a..5f53ca1f81d2ee1a5874660da2b9a23a0aca2568 100644
--- a/pkgs/fourmolu.nix
+++ b/pkgs/fourmolu.nix
@@ -1,9 +1,37 @@
-{ mkDerivation, aeson, ansi-terminal, array, base, bytestring
-, Cabal, containers, Diff, directory, dlist, exceptions, filepath
-, ghc-lib-parser, gitrev, hspec, hspec-discover, hspec-megaparsec
-, lib, megaparsec, MemoTrie, mtl, optparse-applicative, path
-, path-io, pretty, process, QuickCheck, syb, template-haskell
-, temporary, text, th-lift-instances, yaml
+{ mkDerivation
+, aeson
+, ansi-terminal
+, array
+, base
+, bytestring
+, Cabal
+, containers
+, Diff
+, directory
+, dlist
+, exceptions
+, filepath
+, ghc-lib-parser
+, gitrev
+, hspec
+, hspec-discover
+, hspec-megaparsec
+, lib
+, megaparsec
+, MemoTrie
+, mtl
+, optparse-applicative
+, path
+, path-io
+, pretty
+, process
+, QuickCheck
+, syb
+, template-haskell
+, temporary
+, text
+, th-lift-instances
+, yaml
 }:
 mkDerivation {
   pname = "fourmolu";
@@ -12,18 +40,56 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    aeson ansi-terminal array base bytestring Cabal containers Diff
-    directory dlist exceptions filepath ghc-lib-parser megaparsec
-    MemoTrie mtl syb template-haskell text th-lift-instances yaml
+    aeson
+    ansi-terminal
+    array
+    base
+    bytestring
+    Cabal
+    containers
+    Diff
+    directory
+    dlist
+    exceptions
+    filepath
+    ghc-lib-parser
+    megaparsec
+    MemoTrie
+    mtl
+    syb
+    template-haskell
+    text
+    th-lift-instances
+    yaml
   ];
   executableHaskellDepends = [
-    base containers directory filepath ghc-lib-parser gitrev
-    optparse-applicative text yaml
+    base
+    containers
+    directory
+    filepath
+    ghc-lib-parser
+    gitrev
+    optparse-applicative
+    text
+    yaml
   ];
   testHaskellDepends = [
-    base containers Diff directory filepath ghc-lib-parser hspec
-    hspec-megaparsec megaparsec path path-io pretty process QuickCheck
-    temporary text
+    base
+    containers
+    Diff
+    directory
+    filepath
+    ghc-lib-parser
+    hspec
+    hspec-megaparsec
+    megaparsec
+    path
+    path-io
+    pretty
+    process
+    QuickCheck
+    temporary
+    text
   ];
   testToolDepends = [ hspec-discover ];
   doHaddock = false;
@@ -34,4 +100,4 @@ mkDerivation {
   description = "A formatter for Haskell source code";
   license = lib.licenses.bsd3;
   mainProgram = "fourmolu";
-}
\ No newline at end of file
+}
diff --git a/pkgs/generic-lens-core.nix b/pkgs/generic-lens-core.nix
index cf453046fba37d937f4d856701e55804d64338df..3b899c2af0a90881729e9c5e3e4087a2333c4ec4 100644
--- a/pkgs/generic-lens-core.nix
+++ b/pkgs/generic-lens-core.nix
@@ -13,4 +13,4 @@ mkDerivation {
   homepage = "https://github.com/kcsongor/generic-lens";
   description = "Generically derive traversals, lenses and prisms";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/generic-lens-lite.nix b/pkgs/generic-lens-lite.nix
index 2ad1533afb183c09c087c2797e9716d946a55ed9..31bd80896e726f8630bee43f51ece06a87a7f61f 100644
--- a/pkgs/generic-lens-lite.nix
+++ b/pkgs/generic-lens-lite.nix
@@ -14,4 +14,4 @@ mkDerivation {
   homepage = "https://github.com/phadej/generic-lens-lite";
   description = "Monomorphic field lens like with generic-lens";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/generic-optics-lite.nix b/pkgs/generic-optics-lite.nix
index a9fa30c4b9f4929acae064d5aaba65c8eed4018f..c3c3084bfda3b55e14fa1ad9f702577954ab5f78 100644
--- a/pkgs/generic-optics-lite.nix
+++ b/pkgs/generic-optics-lite.nix
@@ -14,4 +14,4 @@ mkDerivation {
   homepage = "https://github.com/phadej/generic-lens-lite";
   description = "Monomorphic field opics like with generic-lens";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/generic-optics.nix b/pkgs/generic-optics.nix
index 85ed4e87cb833365cd88e6be8bc54ece40c3c59c..8424519362328959d5a3b317407c000fbf9a12d6 100644
--- a/pkgs/generic-optics.nix
+++ b/pkgs/generic-optics.nix
@@ -1,5 +1,12 @@
-{ mkDerivation, base, doctest, generic-lens-core, HUnit
-, inspection-testing, lib, optics-core, text
+{ mkDerivation
+, base
+, doctest
+, generic-lens-core
+, HUnit
+, inspection-testing
+, lib
+, optics-core
+, text
 }:
 mkDerivation {
   pname = "generic-optics";
@@ -8,10 +15,17 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "13wkbs8x0clkqzi4xqin89qywpky8jkpz9cxgwsglbpcyw11jvgq";
   libraryHaskellDepends = [
-    base generic-lens-core optics-core text
+    base
+    generic-lens-core
+    optics-core
+    text
   ];
   testHaskellDepends = [
-    base doctest HUnit inspection-testing optics-core
+    base
+    doctest
+    HUnit
+    inspection-testing
+    optics-core
   ];
   doHaddock = false;
   jailbreak = true;
@@ -20,4 +34,4 @@ mkDerivation {
   homepage = "https://github.com/kcsongor/generic-lens";
   description = "Generically derive traversals, lenses and prisms";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/generics-sop.nix b/pkgs/generics-sop.nix
index c2c94b575a873c2c85c9b65a2a66851f3cddfeae..4dd6281f4360f4577597994c1aa3d15bbe369ecc 100644
--- a/pkgs/generics-sop.nix
+++ b/pkgs/generics-sop.nix
@@ -1,5 +1,12 @@
-{ mkDerivation, base, criterion, deepseq, ghc-prim, lib, sop-core
-, template-haskell, th-abstraction
+{ mkDerivation
+, base
+, criterion
+, deepseq
+, ghc-prim
+, lib
+, sop-core
+, template-haskell
+, th-abstraction
 }:
 mkDerivation {
   pname = "generics-sop";
@@ -8,11 +15,18 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "1s8bx25yrjqy1cj9y1s1m8a8qlby9dxjzin16yymz7g39fqcqxz8";
   libraryHaskellDepends = [
-    base ghc-prim sop-core template-haskell th-abstraction
+    base
+    ghc-prim
+    sop-core
+    template-haskell
+    th-abstraction
   ];
   testHaskellDepends = [ base ];
   benchmarkHaskellDepends = [
-    base criterion deepseq template-haskell
+    base
+    criterion
+    deepseq
+    template-haskell
   ];
   doHaddock = false;
   jailbreak = true;
@@ -20,4 +34,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Generic Programming using True Sums of Products";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/genvalidity-aeson.nix b/pkgs/genvalidity-aeson.nix
index 02556e2b5f73301288f43a0c625af8c248c7ab08..62d3ef19725215b6c03bf541d84bea37f8fa0b8b 100644
--- a/pkgs/genvalidity-aeson.nix
+++ b/pkgs/genvalidity-aeson.nix
@@ -1,7 +1,19 @@
-{ mkDerivation, aeson, base, criterion, deepseq, genvalidity
-, genvalidity-criterion, genvalidity-hspec, genvalidity-scientific
-, genvalidity-text, genvalidity-unordered-containers
-, genvalidity-vector, hspec, lib, QuickCheck, validity
+{ mkDerivation
+, aeson
+, base
+, criterion
+, deepseq
+, genvalidity
+, genvalidity-criterion
+, genvalidity-hspec
+, genvalidity-scientific
+, genvalidity-text
+, genvalidity-unordered-containers
+, genvalidity-vector
+, hspec
+, lib
+, QuickCheck
+, validity
 , validity-aeson
 }:
 mkDerivation {
@@ -9,15 +21,30 @@ mkDerivation {
   version = "1.0.0.1";
   sha256 = "6101f09c02b925209673d6aed691e64e60a127f41aff1750b27dc7e18caeba48";
   libraryHaskellDepends = [
-    aeson base genvalidity genvalidity-scientific genvalidity-text
-    genvalidity-unordered-containers genvalidity-vector QuickCheck
-    validity validity-aeson
+    aeson
+    base
+    genvalidity
+    genvalidity-scientific
+    genvalidity-text
+    genvalidity-unordered-containers
+    genvalidity-vector
+    QuickCheck
+    validity
+    validity-aeson
   ];
   testHaskellDepends = [
-    aeson base deepseq genvalidity genvalidity-hspec hspec
+    aeson
+    base
+    deepseq
+    genvalidity
+    genvalidity-hspec
+    hspec
   ];
   benchmarkHaskellDepends = [
-    aeson base criterion genvalidity-criterion
+    aeson
+    base
+    criterion
+    genvalidity-criterion
   ];
   doHaddock = false;
   jailbreak = true;
@@ -26,4 +53,4 @@ mkDerivation {
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for aeson";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/genvalidity-bytestring.nix b/pkgs/genvalidity-bytestring.nix
index 1e633fd5e756150b4fb42b819c2db74a3d95897b..57eb5f05c2fb67dbf903363ef9668b2699ebe4cb 100644
--- a/pkgs/genvalidity-bytestring.nix
+++ b/pkgs/genvalidity-bytestring.nix
@@ -1,21 +1,47 @@
-{ mkDerivation, base, bytestring, criterion, deepseq, genvalidity
-, genvalidity-criterion, genvalidity-hspec, hspec, lib, QuickCheck
-, random, validity, validity-bytestring
+{ mkDerivation
+, base
+, bytestring
+, criterion
+, deepseq
+, genvalidity
+, genvalidity-criterion
+, genvalidity-hspec
+, hspec
+, lib
+, QuickCheck
+, random
+, validity
+, validity-bytestring
 }:
 mkDerivation {
   pname = "genvalidity-bytestring";
   version = "1.0.0.1";
   sha256 = "3311f83fabcd549785b009868c63e53723774fa35fe755fe7bfc537c082c6dbb";
   libraryHaskellDepends = [
-    base bytestring genvalidity QuickCheck random validity
+    base
+    bytestring
+    genvalidity
+    QuickCheck
+    random
+    validity
     validity-bytestring
   ];
   testHaskellDepends = [
-    base bytestring deepseq genvalidity genvalidity-hspec hspec
-    QuickCheck validity
+    base
+    bytestring
+    deepseq
+    genvalidity
+    genvalidity-hspec
+    hspec
+    QuickCheck
+    validity
   ];
   benchmarkHaskellDepends = [
-    base bytestring criterion genvalidity genvalidity-criterion
+    base
+    bytestring
+    criterion
+    genvalidity
+    genvalidity-criterion
     QuickCheck
   ];
   doHaddock = false;
@@ -25,4 +51,4 @@ mkDerivation {
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for ByteString";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/genvalidity-hspec.nix b/pkgs/genvalidity-hspec.nix
index bf6376e017cce7a561133a207f550e603aa12e13..07a5d281a3dc043711bcdbbb8c32bea1ff8a4e3b 100644
--- a/pkgs/genvalidity-hspec.nix
+++ b/pkgs/genvalidity-hspec.nix
@@ -1,16 +1,34 @@
-{ mkDerivation, base, genvalidity, genvalidity-property, hspec
-, hspec-core, lib, QuickCheck, transformers, validity
+{ mkDerivation
+, base
+, genvalidity
+, genvalidity-property
+, hspec
+, hspec-core
+, lib
+, QuickCheck
+, transformers
+, validity
 }:
 mkDerivation {
   pname = "genvalidity-hspec";
   version = "1.0.0.2";
   sha256 = "84f9a27f7345616162e80081b867961734fc750acdbac40e64c5db4d7f055b03";
   libraryHaskellDepends = [
-    base genvalidity genvalidity-property hspec hspec-core QuickCheck
-    transformers validity
+    base
+    genvalidity
+    genvalidity-property
+    hspec
+    hspec-core
+    QuickCheck
+    transformers
+    validity
   ];
   testHaskellDepends = [
-    base genvalidity hspec hspec-core QuickCheck
+    base
+    genvalidity
+    hspec
+    hspec-core
+    QuickCheck
   ];
   doHaddock = false;
   jailbreak = true;
@@ -19,4 +37,4 @@ mkDerivation {
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Standard spec's for GenValidity instances";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/genvalidity-scientific.nix b/pkgs/genvalidity-scientific.nix
index 4649d182696c833f3c04f2140899d84cda94fcd3..9bb4f8ada0d015fc9917f1be8d68472201190715 100644
--- a/pkgs/genvalidity-scientific.nix
+++ b/pkgs/genvalidity-scientific.nix
@@ -1,15 +1,33 @@
-{ mkDerivation, base, genvalidity, genvalidity-hspec, hspec, lib
-, QuickCheck, scientific, validity, validity-scientific
+{ mkDerivation
+, base
+, genvalidity
+, genvalidity-hspec
+, hspec
+, lib
+, QuickCheck
+, scientific
+, validity
+, validity-scientific
 }:
 mkDerivation {
   pname = "genvalidity-scientific";
   version = "1.0.0.0";
   sha256 = "b85e13c3f54ed955f6d568503d9cda49162f3a4af7560acac62df8a565502176";
   libraryHaskellDepends = [
-    base genvalidity QuickCheck scientific validity validity-scientific
+    base
+    genvalidity
+    QuickCheck
+    scientific
+    validity
+    validity-scientific
   ];
   testHaskellDepends = [
-    base genvalidity genvalidity-hspec hspec QuickCheck scientific
+    base
+    genvalidity
+    genvalidity-hspec
+    hspec
+    QuickCheck
+    scientific
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +36,4 @@ mkDerivation {
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for Scientific";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/genvalidity-sydtest-aeson.nix b/pkgs/genvalidity-sydtest-aeson.nix
index fc398541fd76d6389ffe0d7e09c9a658e349c89f..fe539e05a08aca29168a4c6500656cbf1dd9b07f 100644
--- a/pkgs/genvalidity-sydtest-aeson.nix
+++ b/pkgs/genvalidity-sydtest-aeson.nix
@@ -1,18 +1,44 @@
-{ mkDerivation, aeson, base, bytestring, deepseq, genvalidity
-, genvalidity-aeson, genvalidity-sydtest, genvalidity-text, lib
-, QuickCheck, sydtest, sydtest-discover, text, validity
+{ mkDerivation
+, aeson
+, base
+, bytestring
+, deepseq
+, genvalidity
+, genvalidity-aeson
+, genvalidity-sydtest
+, genvalidity-text
+, lib
+, QuickCheck
+, sydtest
+, sydtest-discover
+, text
+, validity
 }:
 mkDerivation {
   pname = "genvalidity-sydtest-aeson";
   version = "1.0.0.0";
   sha256 = "02ecfc0ecabc6310018ce8ecca220d6388367294c4a1e6b2bbfc9d5de00116d9";
   libraryHaskellDepends = [
-    aeson base bytestring deepseq genvalidity genvalidity-sydtest
-    QuickCheck sydtest
+    aeson
+    base
+    bytestring
+    deepseq
+    genvalidity
+    genvalidity-sydtest
+    QuickCheck
+    sydtest
   ];
   testHaskellDepends = [
-    aeson base genvalidity genvalidity-aeson genvalidity-sydtest
-    genvalidity-text QuickCheck sydtest text validity
+    aeson
+    base
+    genvalidity
+    genvalidity-aeson
+    genvalidity-sydtest
+    genvalidity-text
+    QuickCheck
+    sydtest
+    text
+    validity
   ];
   testToolDepends = [ sydtest-discover ];
   doHaddock = false;
@@ -22,4 +48,4 @@ mkDerivation {
   homepage = "http://cs-syd.eu";
   description = "Standard spec's for aeson-related instances in sydtest";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/genvalidity-text.nix b/pkgs/genvalidity-text.nix
index 414fe6fd99514ea27f413af41ca0d199bd211c98..5e420052dba0ed93b9cfa0f6e6274b2a8b4cca2d 100644
--- a/pkgs/genvalidity-text.nix
+++ b/pkgs/genvalidity-text.nix
@@ -1,20 +1,47 @@
-{ mkDerivation, array, base, criterion, genvalidity
-, genvalidity-criterion, genvalidity-hspec, hspec, lib, QuickCheck
-, random, text, validity, validity-text
+{ mkDerivation
+, array
+, base
+, criterion
+, genvalidity
+, genvalidity-criterion
+, genvalidity-hspec
+, hspec
+, lib
+, QuickCheck
+, random
+, text
+, validity
+, validity-text
 }:
 mkDerivation {
   pname = "genvalidity-text";
   version = "1.0.0.1";
   sha256 = "96e19453e45d76cb89794801588a6d9726c5092fef5cd053e7abe4322f553be3";
   libraryHaskellDepends = [
-    array base genvalidity QuickCheck random text validity
+    array
+    base
+    genvalidity
+    QuickCheck
+    random
+    text
+    validity
     validity-text
   ];
   testHaskellDepends = [
-    base genvalidity genvalidity-hspec hspec QuickCheck text
+    base
+    genvalidity
+    genvalidity-hspec
+    hspec
+    QuickCheck
+    text
   ];
   benchmarkHaskellDepends = [
-    base criterion genvalidity genvalidity-criterion QuickCheck text
+    base
+    criterion
+    genvalidity
+    genvalidity-criterion
+    QuickCheck
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -23,4 +50,4 @@ mkDerivation {
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for Text";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/genvalidity-unordered-containers.nix b/pkgs/genvalidity-unordered-containers.nix
index 050481368f59b84f3981596c69f8bacf801f5cef..1875a45e015a0a345090a6053549d5bfaaac1efd 100644
--- a/pkgs/genvalidity-unordered-containers.nix
+++ b/pkgs/genvalidity-unordered-containers.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, base, genvalidity, genvalidity-hspec, hashable
-, hspec, lib, QuickCheck, unordered-containers, validity
+{ mkDerivation
+, base
+, genvalidity
+, genvalidity-hspec
+, hashable
+, hspec
+, lib
+, QuickCheck
+, unordered-containers
+, validity
 , validity-unordered-containers
 }:
 mkDerivation {
@@ -7,11 +15,20 @@ mkDerivation {
   version = "1.0.0.0";
   sha256 = "b325c19594853133b62019ad35ed86616b92ac1afd18a5f49a801e3e453fa6e9";
   libraryHaskellDepends = [
-    base genvalidity hashable QuickCheck unordered-containers validity
+    base
+    genvalidity
+    hashable
+    QuickCheck
+    unordered-containers
+    validity
     validity-unordered-containers
   ];
   testHaskellDepends = [
-    base genvalidity genvalidity-hspec hspec unordered-containers
+    base
+    genvalidity
+    genvalidity-hspec
+    hspec
+    unordered-containers
     validity
   ];
   doHaddock = false;
@@ -21,4 +38,4 @@ mkDerivation {
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for unordered-containers";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/genvalidity-vector.nix b/pkgs/genvalidity-vector.nix
index 9798d1d3d88242f9c56a138d8fd1b9b514f358e6..7d244fd64a86e5d2825ae9eccf8f1d0e427132fc 100644
--- a/pkgs/genvalidity-vector.nix
+++ b/pkgs/genvalidity-vector.nix
@@ -1,15 +1,32 @@
-{ mkDerivation, base, genvalidity, genvalidity-hspec, hspec, lib
-, QuickCheck, validity, validity-vector, vector
+{ mkDerivation
+, base
+, genvalidity
+, genvalidity-hspec
+, hspec
+, lib
+, QuickCheck
+, validity
+, validity-vector
+, vector
 }:
 mkDerivation {
   pname = "genvalidity-vector";
   version = "1.0.0.0";
   sha256 = "fe0dd139da3cafe4a4e05ed19e3efb46743f92743f95615fefbd8027dd925fd0";
   libraryHaskellDepends = [
-    base genvalidity QuickCheck validity validity-vector vector
+    base
+    genvalidity
+    QuickCheck
+    validity
+    validity-vector
+    vector
   ];
   testHaskellDepends = [
-    base genvalidity genvalidity-hspec hspec vector
+    base
+    genvalidity
+    genvalidity-hspec
+    hspec
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +35,4 @@ mkDerivation {
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for vector";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ghc-byteorder.nix b/pkgs/ghc-byteorder.nix
index 51612c3f4420960ce3ae407b13ded5cc7fdcda20..aca29e0ce3a8ed0119e0fc772713ab538d180198 100644
--- a/pkgs/ghc-byteorder.nix
+++ b/pkgs/ghc-byteorder.nix
@@ -13,4 +13,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "\"GHC.ByteOrder\" API Compatibility Layer";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ghc-check.nix b/pkgs/ghc-check.nix
index b07965c5305dd5a929581e5ab061b5cb8ad6030c..f7afb738049e4de11d36d2a41228c669fc6c50da 100644
--- a/pkgs/ghc-check.nix
+++ b/pkgs/ghc-check.nix
@@ -1,14 +1,35 @@
-{ mkDerivation, base, containers, directory, filepath, ghc
-, ghc-boot, ghc-paths, lib, process, safe-exceptions
-, template-haskell, th-compat, transformers
+{ mkDerivation
+, base
+, containers
+, directory
+, filepath
+, ghc
+, ghc-boot
+, ghc-paths
+, lib
+, process
+, safe-exceptions
+, template-haskell
+, th-compat
+, transformers
 }:
 mkDerivation {
   pname = "ghc-check";
   version = "0.5.0.8";
   sha256 = "1025a8353fb7c318b27b8dc6b268d22f1f64c271031ed0ce4defb0f9100d7cd4";
   libraryHaskellDepends = [
-    base containers directory filepath ghc ghc-boot ghc-paths process
-    safe-exceptions template-haskell th-compat transformers
+    base
+    containers
+    directory
+    filepath
+    ghc
+    ghc-boot
+    ghc-paths
+    process
+    safe-exceptions
+    template-haskell
+    th-compat
+    transformers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -16,4 +37,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "detect mismatches between compile-time and run-time versions of the ghc api";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ghc-exactprint.nix b/pkgs/ghc-exactprint.nix
index af0237385c664451c7c6c3924969af6078fe9801..7628f6187035fc002f2a2d7b49defb69ace8807c 100644
--- a/pkgs/ghc-exactprint.nix
+++ b/pkgs/ghc-exactprint.nix
@@ -1,7 +1,24 @@
-{ mkDerivation, base, bytestring, Cabal-syntax, containers
-, data-default, Diff, directory, fail, filemanip, filepath, free
-, ghc, ghc-boot, ghc-paths, HUnit, lib, mtl, ordered-containers
-, silently, syb
+{ mkDerivation
+, base
+, bytestring
+, Cabal-syntax
+, containers
+, data-default
+, Diff
+, directory
+, fail
+, filemanip
+, filepath
+, free
+, ghc
+, ghc-boot
+, ghc-paths
+, HUnit
+, lib
+, mtl
+, ordered-containers
+, silently
+, syb
 }:
 mkDerivation {
   pname = "ghc-exactprint";
@@ -10,13 +27,39 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base bytestring containers data-default directory fail filepath
-    free ghc ghc-boot mtl ordered-containers syb
+    base
+    bytestring
+    containers
+    data-default
+    directory
+    fail
+    filepath
+    free
+    ghc
+    ghc-boot
+    mtl
+    ordered-containers
+    syb
   ];
   testHaskellDepends = [
-    base bytestring Cabal-syntax containers data-default Diff directory
-    fail filemanip filepath ghc ghc-boot ghc-paths HUnit mtl
-    ordered-containers silently syb
+    base
+    bytestring
+    Cabal-syntax
+    containers
+    data-default
+    Diff
+    directory
+    fail
+    filemanip
+    filepath
+    ghc
+    ghc-boot
+    ghc-paths
+    HUnit
+    mtl
+    ordered-containers
+    silently
+    syb
   ];
   doHaddock = false;
   jailbreak = true;
@@ -24,4 +67,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "ExactPrint for GHC";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ghc-lib-parser-ex.nix b/pkgs/ghc-lib-parser-ex.nix
index 31f9bdff2e34fe54fe148fa2799ac144f4505672..e715402f5ad0b3dd534defc453b216f741d3b87e 100644
--- a/pkgs/ghc-lib-parser-ex.nix
+++ b/pkgs/ghc-lib-parser-ex.nix
@@ -1,15 +1,35 @@
-{ mkDerivation, base, bytestring, containers, directory, extra
-, filepath, ghc-lib-parser, lib, tasty, tasty-hunit, uniplate
+{ mkDerivation
+, base
+, bytestring
+, containers
+, directory
+, extra
+, filepath
+, ghc-lib-parser
+, lib
+, tasty
+, tasty-hunit
+, uniplate
 }:
 mkDerivation {
   pname = "ghc-lib-parser-ex";
   version = "9.4.0.0";
   sha256 = "ce3ff339a0a259a18ae921c547b35732eaca1a567a33fba1a7c65c16c973191b";
   libraryHaskellDepends = [
-    base bytestring containers ghc-lib-parser uniplate
+    base
+    bytestring
+    containers
+    ghc-lib-parser
+    uniplate
   ];
   testHaskellDepends = [
-    base directory extra filepath ghc-lib-parser tasty tasty-hunit
+    base
+    directory
+    extra
+    filepath
+    ghc-lib-parser
+    tasty
+    tasty-hunit
     uniplate
   ];
   doHaddock = false;
@@ -19,4 +39,4 @@ mkDerivation {
   homepage = "https://github.com/shayne-fletcher/ghc-lib-parser-ex#readme";
   description = "Algorithms on GHC parse trees";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ghc-lib-parser.nix b/pkgs/ghc-lib-parser.nix
index 34daced18f7ad0613fa1e63beae6cc420bbb6d52..795e8fcf224fd57d1577d442afa0e0ecb2004344 100644
--- a/pkgs/ghc-lib-parser.nix
+++ b/pkgs/ghc-lib-parser.nix
@@ -1,6 +1,23 @@
-{ mkDerivation, alex, array, base, binary, bytestring, containers
-, deepseq, directory, exceptions, filepath, ghc-prim, happy, lib
-, parsec, pretty, process, time, transformers, unix
+{ mkDerivation
+, alex
+, array
+, base
+, binary
+, bytestring
+, containers
+, deepseq
+, directory
+, exceptions
+, filepath
+, ghc-prim
+, happy
+, lib
+, parsec
+, pretty
+, process
+, time
+, transformers
+, unix
 }:
 mkDerivation {
   pname = "ghc-lib-parser";
@@ -8,9 +25,22 @@ mkDerivation {
   sha256 = "3eb1fd79734728fffb39c98a4a42747d0db2d35380fec8ab24bbea5d76b93847";
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
-    array base binary bytestring containers deepseq directory
-    exceptions filepath ghc-prim parsec pretty process time
-    transformers unix
+    array
+    base
+    binary
+    bytestring
+    containers
+    deepseq
+    directory
+    exceptions
+    filepath
+    ghc-prim
+    parsec
+    pretty
+    process
+    time
+    transformers
+    unix
   ];
   libraryToolDepends = [ alex happy ];
   doHaddock = false;
@@ -20,4 +50,4 @@ mkDerivation {
   homepage = "https://github.com/digital-asset/ghc-lib";
   description = "The GHC API, decoupled from GHC versions";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ghc-paths.nix b/pkgs/ghc-paths.nix
index 2bde896593cd7c85d9091a5534641c7d024637b5..27e88a00d73caf247e28fe98bcf377a566bdb5f5 100644
--- a/pkgs/ghc-paths.nix
+++ b/pkgs/ghc-paths.nix
@@ -13,4 +13,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Knowledge of GHC's installation directories";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/ghc-tcplugins-extra.nix b/pkgs/ghc-tcplugins-extra.nix
index f0857eb9add887b6d45be1adefe3ac599c77c6e7..63eb1593c87b40984894d085298abcf6560a23b7 100644
--- a/pkgs/ghc-tcplugins-extra.nix
+++ b/pkgs/ghc-tcplugins-extra.nix
@@ -11,4 +11,4 @@ mkDerivation {
   homepage = "https://github.com/clash-lang/ghc-tcplugins-extra#readme";
   description = "Utilities for writing GHC type-checker plugins";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+}
diff --git a/pkgs/hackage-security.nix b/pkgs/hackage-security.nix
index 52c257b6bed3c1f945dd6f87d07219317fde3151..967f1f018aede1cb57eddc529a4769efa7042077 100644
--- a/pkgs/hackage-security.nix
+++ b/pkgs/hackage-security.nix
@@ -1,9 +1,37 @@
-{ mkDerivation, aeson, base, base16-bytestring, base64-bytestring
-, bytestring, Cabal, Cabal-syntax, containers, cryptohash-sha256
-, directory, ed25519, filepath, ghc-prim, lib, lukko, mtl, network
-, network-uri, parsec, pretty, QuickCheck, tar, tasty, tasty-hunit
-, tasty-quickcheck, template-haskell, temporary, text, time
-, transformers, unordered-containers, vector, zlib
+{ mkDerivation
+, aeson
+, base
+, base16-bytestring
+, base64-bytestring
+, bytestring
+, Cabal
+, Cabal-syntax
+, containers
+, cryptohash-sha256
+, directory
+, ed25519
+, filepath
+, ghc-prim
+, lib
+, lukko
+, mtl
+, network
+, network-uri
+, parsec
+, pretty
+, QuickCheck
+, tar
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, template-haskell
+, temporary
+, text
+, time
+, transformers
+, unordered-containers
+, vector
+, zlib
 }:
 mkDerivation {
   pname = "hackage-security";
@@ -12,15 +40,49 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "01fhp3kzc1wfvixzgnz4y52bzm4sickk1cj7pksrwmbi90dghv0s";
   libraryHaskellDepends = [
-    base base16-bytestring base64-bytestring bytestring Cabal
-    Cabal-syntax containers cryptohash-sha256 directory ed25519
-    filepath ghc-prim lukko mtl network network-uri parsec pretty tar
-    template-haskell time transformers zlib
+    base
+    base16-bytestring
+    base64-bytestring
+    bytestring
+    Cabal
+    Cabal-syntax
+    containers
+    cryptohash-sha256
+    directory
+    ed25519
+    filepath
+    ghc-prim
+    lukko
+    mtl
+    network
+    network-uri
+    parsec
+    pretty
+    tar
+    template-haskell
+    time
+    transformers
+    zlib
   ];
   testHaskellDepends = [
-    aeson base bytestring Cabal Cabal-syntax containers network-uri
-    QuickCheck tar tasty tasty-hunit tasty-quickcheck temporary text
-    time unordered-containers vector zlib
+    aeson
+    base
+    bytestring
+    Cabal
+    Cabal-syntax
+    containers
+    network-uri
+    QuickCheck
+    tar
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    temporary
+    text
+    time
+    unordered-containers
+    vector
+    zlib
   ];
   doHaddock = false;
   jailbreak = true;
@@ -29,4 +91,4 @@ mkDerivation {
   homepage = "https://github.com/haskell/hackage-security";
   description = "Hackage security library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/hashable.nix b/pkgs/hashable.nix
index e9fc942f99263ba9aca67235adc74ef4ea4380da..70854eb4cba9e6ed15d36e6e577a89844bbb619c 100644
--- a/pkgs/hashable.nix
+++ b/pkgs/hashable.nix
@@ -1,17 +1,45 @@
-{ mkDerivation, base, bytestring, containers, deepseq, ghc-bignum
-, ghc-prim, HUnit, lib, QuickCheck, random, test-framework
-, test-framework-hunit, test-framework-quickcheck2, text, unix
+{ mkDerivation
+, base
+, bytestring
+, containers
+, deepseq
+, ghc-bignum
+, ghc-prim
+, HUnit
+, lib
+, QuickCheck
+, random
+, test-framework
+, test-framework-hunit
+, test-framework-quickcheck2
+, text
+, unix
 }:
 mkDerivation {
   pname = "hashable";
   version = "1.4.1.0";
   sha256 = "e1b305c280e66ad827edeaedd6933b9fc4174f626882877eab2a08344e665e87";
   libraryHaskellDepends = [
-    base bytestring containers deepseq ghc-bignum ghc-prim text
+    base
+    bytestring
+    containers
+    deepseq
+    ghc-bignum
+    ghc-prim
+    text
   ];
   testHaskellDepends = [
-    base bytestring ghc-prim HUnit QuickCheck random test-framework
-    test-framework-hunit test-framework-quickcheck2 text unix
+    base
+    bytestring
+    ghc-prim
+    HUnit
+    QuickCheck
+    random
+    test-framework
+    test-framework-hunit
+    test-framework-quickcheck2
+    text
+    unix
   ];
   doHaddock = false;
   jailbreak = true;
@@ -20,4 +48,4 @@ mkDerivation {
   homepage = "http://github.com/haskell-unordered-containers/hashable";
   description = "A class for types that can be converted to a hash value";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/hashing.nix b/pkgs/hashing.nix
index 50d92192c1969d03e528c2682683ea953f5a6b44..c041019fac3d593e1cf7f4fe69ee389afb3c9b4b 100644
--- a/pkgs/hashing.nix
+++ b/pkgs/hashing.nix
@@ -1,5 +1,12 @@
-{ mkDerivation, array, base, bytestring, cryptonite, lib, mtl
-, QuickCheck, template-haskell
+{ mkDerivation
+, array
+, base
+, bytestring
+, cryptonite
+, lib
+, mtl
+, QuickCheck
+, template-haskell
 }:
 mkDerivation {
   pname = "hashing";
@@ -11,10 +18,20 @@ mkDerivation {
   isExecutable = true;
   libraryHaskellDepends = [ array base bytestring ];
   executableHaskellDepends = [
-    array base bytestring mtl QuickCheck
+    array
+    base
+    bytestring
+    mtl
+    QuickCheck
   ];
   testHaskellDepends = [
-    array base bytestring cryptonite mtl QuickCheck template-haskell
+    array
+    base
+    bytestring
+    cryptonite
+    mtl
+    QuickCheck
+    template-haskell
   ];
   doHaddock = false;
   jailbreak = true;
@@ -24,4 +41,4 @@ mkDerivation {
   description = "A pure haskell library implements several hash algorithms";
   license = lib.licenses.mit;
   mainProgram = "hashing-exe";
-}
\ No newline at end of file
+}
diff --git a/pkgs/hashtables.nix b/pkgs/hashtables.nix
index 8cd9af128da85be3b35d200a80d6305f44fa146f..c40b0c141a2772dbf11a846c1d8313d7ae400001 100644
--- a/pkgs/hashtables.nix
+++ b/pkgs/hashtables.nix
@@ -1,17 +1,39 @@
-{ mkDerivation, base, ghc-prim, hashable, HUnit, lib, mwc-random
-, primitive, QuickCheck, test-framework, test-framework-hunit
-, test-framework-quickcheck2, vector
+{ mkDerivation
+, base
+, ghc-prim
+, hashable
+, HUnit
+, lib
+, mwc-random
+, primitive
+, QuickCheck
+, test-framework
+, test-framework-hunit
+, test-framework-quickcheck2
+, vector
 }:
 mkDerivation {
   pname = "hashtables";
   version = "1.3";
   sha256 = "af785a6d13842ebbd804b0ec174dd957a2591b224434e3ce883f537321f90dd3";
   libraryHaskellDepends = [
-    base ghc-prim hashable primitive vector
+    base
+    ghc-prim
+    hashable
+    primitive
+    vector
   ];
   testHaskellDepends = [
-    base ghc-prim hashable HUnit mwc-random primitive QuickCheck
-    test-framework test-framework-hunit test-framework-quickcheck2
+    base
+    ghc-prim
+    hashable
+    HUnit
+    mwc-random
+    primitive
+    QuickCheck
+    test-framework
+    test-framework-hunit
+    test-framework-quickcheck2
     vector
   ];
   doHaddock = false;
@@ -21,4 +43,4 @@ mkDerivation {
   homepage = "http://github.com/gregorycollins/hashtables";
   description = "Mutable hash tables in the ST monad";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/haskell-src-meta.nix b/pkgs/haskell-src-meta.nix
index 9e39913dbe5b7ddca4b6581bf00629066d020938..2744558e3cc83d679b665947fe64797500953230 100644
--- a/pkgs/haskell-src-meta.nix
+++ b/pkgs/haskell-src-meta.nix
@@ -1,15 +1,37 @@
-{ mkDerivation, base, containers, haskell-src-exts, HUnit, lib
-, pretty, syb, tasty, tasty-hunit, template-haskell, th-orphans
+{ mkDerivation
+, base
+, containers
+, haskell-src-exts
+, HUnit
+, lib
+, pretty
+, syb
+, tasty
+, tasty-hunit
+, template-haskell
+, th-orphans
 }:
 mkDerivation {
   pname = "haskell-src-meta";
   version = "0.8.11";
   sha256 = "3ca7fb27deceb3116682c24d9c122dc4c328a7566c39076c924f407556077af2";
   libraryHaskellDepends = [
-    base haskell-src-exts pretty syb template-haskell th-orphans
+    base
+    haskell-src-exts
+    pretty
+    syb
+    template-haskell
+    th-orphans
   ];
   testHaskellDepends = [
-    base containers haskell-src-exts HUnit pretty syb tasty tasty-hunit
+    base
+    containers
+    haskell-src-exts
+    HUnit
+    pretty
+    syb
+    tasty
+    tasty-hunit
     template-haskell
   ];
   doHaddock = false;
@@ -18,4 +40,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Parse source to template-haskell abstract syntax";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/hedgehog-golden.nix b/pkgs/hedgehog-golden.nix
index d635f1ab54021da3ff1d7b5a1b7ac1823b033e58..589cb605e922fef2484df1463a189b407d22462d 100644
--- a/pkgs/hedgehog-golden.nix
+++ b/pkgs/hedgehog-golden.nix
@@ -1,5 +1,17 @@
-{ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
-, Diff, directory, extra, fetchgit, hedgehog, lib, text, with-utf8
+{ mkDerivation
+, aeson
+, aeson-pretty
+, base
+, bytestring
+, containers
+, Diff
+, directory
+, extra
+, fetchgit
+, hedgehog
+, lib
+, text
+, with-utf8
 }:
 mkDerivation {
   pname = "hedgehog-golden";
@@ -12,8 +24,16 @@ mkDerivation {
   };
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
-    aeson aeson-pretty base bytestring containers Diff directory extra
-    hedgehog text
+    aeson
+    aeson-pretty
+    base
+    bytestring
+    containers
+    Diff
+    directory
+    extra
+    hedgehog
+    text
   ];
   testHaskellDepends = [ aeson base hedgehog with-utf8 ];
   doHaddock = false;
@@ -23,4 +43,4 @@ mkDerivation {
   homepage = "https://github.com/felixmulder/hedgehog-golden";
   description = "Golden testing capabilities for hedgehog using Aeson";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/hedgehog.nix b/pkgs/hedgehog.nix
index fe92c29b890a269fc08cf35a7305fec7b2d925ba..50df676ac179ec2abf9a81dfb57fbb91679fb860 100644
--- a/pkgs/hedgehog.nix
+++ b/pkgs/hedgehog.nix
@@ -1,22 +1,72 @@
-{ mkDerivation, ansi-terminal, async, barbies, base, bytestring
-, concurrent-output, containers, deepseq, directory, erf
-, exceptions, lib, lifted-async, mmorph, monad-control, mtl
-, pretty-show, primitive, random, resourcet, stm, template-haskell
-, text, time, transformers, transformers-base, wl-pprint-annotated
+{ mkDerivation
+, ansi-terminal
+, async
+, barbies
+, base
+, bytestring
+, concurrent-output
+, containers
+, deepseq
+, directory
+, erf
+, exceptions
+, lib
+, lifted-async
+, mmorph
+, monad-control
+, mtl
+, pretty-show
+, primitive
+, random
+, resourcet
+, stm
+, template-haskell
+, text
+, time
+, transformers
+, transformers-base
+, wl-pprint-annotated
 }:
 mkDerivation {
   pname = "hedgehog";
   version = "1.2";
   sha256 = "2859c7daa665250bb249614da7b55507c6315d9b80e456f1a74f33abfeaf8e7e";
   libraryHaskellDepends = [
-    ansi-terminal async barbies base bytestring concurrent-output
-    containers deepseq directory erf exceptions lifted-async mmorph
-    monad-control mtl pretty-show primitive random resourcet stm
-    template-haskell text time transformers transformers-base
+    ansi-terminal
+    async
+    barbies
+    base
+    bytestring
+    concurrent-output
+    containers
+    deepseq
+    directory
+    erf
+    exceptions
+    lifted-async
+    mmorph
+    monad-control
+    mtl
+    pretty-show
+    primitive
+    random
+    resourcet
+    stm
+    template-haskell
+    text
+    time
+    transformers
+    transformers-base
     wl-pprint-annotated
   ];
   testHaskellDepends = [
-    base containers mmorph mtl pretty-show text transformers
+    base
+    containers
+    mmorph
+    mtl
+    pretty-show
+    text
+    transformers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -25,4 +75,4 @@ mkDerivation {
   homepage = "https://hedgehog.qa";
   description = "Release with confidence";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/hie-compat.nix b/pkgs/hie-compat.nix
index 24c1171360218be8ff3fe9b452306ede22e02882..8e207544c31e13d28cbd9d5a9e0282acdadaa3b8 100644
--- a/pkgs/hie-compat.nix
+++ b/pkgs/hie-compat.nix
@@ -1,12 +1,28 @@
-{ mkDerivation, array, base, bytestring, containers, directory
-, filepath, ghc, ghc-boot, lib, transformers
+{ mkDerivation
+, array
+, base
+, bytestring
+, containers
+, directory
+, filepath
+, ghc
+, ghc-boot
+, lib
+, transformers
 }:
 mkDerivation {
   pname = "hie-compat";
   version = "0.3.0.0";
   sha256 = "ab02e969106971f7ef980515f802447c579c088b2e227eb8982999605f392199";
   libraryHaskellDepends = [
-    array base bytestring containers directory filepath ghc ghc-boot
+    array
+    base
+    bytestring
+    containers
+    directory
+    filepath
+    ghc
+    ghc-boot
     transformers
   ];
   doHaddock = false;
@@ -16,4 +32,4 @@ mkDerivation {
   homepage = "https://github.com/haskell/haskell-language-server/tree/master/hie-compat#readme";
   description = "HIE files for GHC 8.6 and other HIE file backports";
   license = lib.licenses.asl20;
-}
\ No newline at end of file
+}
diff --git a/pkgs/hiedb.nix b/pkgs/hiedb.nix
index 539022355aaddb1fc81e6def63ed7cb0644df72f..94a285ee46bf5e8f2780398176a1ce409994a2cc 100644
--- a/pkgs/hiedb.nix
+++ b/pkgs/hiedb.nix
@@ -1,8 +1,26 @@
-{ mkDerivation, algebraic-graphs, ansi-terminal, array, base
-, bytestring, containers, directory, extra, filepath, ghc
-, ghc-paths, hie-compat, hspec, lib, lucid, mtl
-, optparse-applicative, process, sqlite-simple, temporary
-, terminal-size, text
+{ mkDerivation
+, algebraic-graphs
+, ansi-terminal
+, array
+, base
+, bytestring
+, containers
+, directory
+, extra
+, filepath
+, ghc
+, ghc-paths
+, hie-compat
+, hspec
+, lib
+, lucid
+, mtl
+, optparse-applicative
+, process
+, sqlite-simple
+, temporary
+, terminal-size
+, text
 }:
 mkDerivation {
   pname = "hiedb";
@@ -11,13 +29,34 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    algebraic-graphs ansi-terminal array base bytestring containers
-    directory extra filepath ghc hie-compat lucid mtl
-    optparse-applicative sqlite-simple terminal-size text
+    algebraic-graphs
+    ansi-terminal
+    array
+    base
+    bytestring
+    containers
+    directory
+    extra
+    filepath
+    ghc
+    hie-compat
+    lucid
+    mtl
+    optparse-applicative
+    sqlite-simple
+    terminal-size
+    text
   ];
   executableHaskellDepends = [ base ghc-paths ];
   testHaskellDepends = [
-    base directory filepath ghc ghc-paths hspec process temporary
+    base
+    directory
+    filepath
+    ghc
+    ghc-paths
+    hspec
+    process
+    temporary
   ];
   doHaddock = false;
   jailbreak = true;
@@ -26,4 +65,4 @@ mkDerivation {
   description = "Generates a references DB from .hie files";
   license = lib.licenses.bsd3;
   mainProgram = "hiedb";
-}
\ No newline at end of file
+}
diff --git a/pkgs/hlint.nix b/pkgs/hlint.nix
index 359d6c15f5f38eaab2373b2d207f14087dbe9d7b..1f422da015a210a3fa58a3964487b587c26b0f26 100644
--- a/pkgs/hlint.nix
+++ b/pkgs/hlint.nix
@@ -1,8 +1,30 @@
-{ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
-, containers, cpphs, data-default, deriving-aeson, directory, extra
-, file-embed, filepath, filepattern, ghc-lib-parser
-, ghc-lib-parser-ex, hscolour, lib, process, refact, text
-, transformers, uniplate, unordered-containers, utf8-string, vector
+{ mkDerivation
+, aeson
+, ansi-terminal
+, base
+, bytestring
+, cmdargs
+, containers
+, cpphs
+, data-default
+, deriving-aeson
+, directory
+, extra
+, file-embed
+, filepath
+, filepattern
+, ghc-lib-parser
+, ghc-lib-parser-ex
+, hscolour
+, lib
+, process
+, refact
+, text
+, transformers
+, uniplate
+, unordered-containers
+, utf8-string
+, vector
 , yaml
 }:
 mkDerivation {
@@ -13,11 +35,32 @@ mkDerivation {
   isExecutable = true;
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
-    aeson ansi-terminal base bytestring cmdargs containers cpphs
-    data-default deriving-aeson directory extra file-embed filepath
-    filepattern ghc-lib-parser ghc-lib-parser-ex hscolour process
-    refact text transformers uniplate unordered-containers utf8-string
-    vector yaml
+    aeson
+    ansi-terminal
+    base
+    bytestring
+    cmdargs
+    containers
+    cpphs
+    data-default
+    deriving-aeson
+    directory
+    extra
+    file-embed
+    filepath
+    filepattern
+    ghc-lib-parser
+    ghc-lib-parser-ex
+    hscolour
+    process
+    refact
+    text
+    transformers
+    uniplate
+    unordered-containers
+    utf8-string
+    vector
+    yaml
   ];
   executableHaskellDepends = [ base ];
   doHaddock = false;
@@ -28,4 +71,4 @@ mkDerivation {
   description = "Source code suggestions";
   license = lib.licenses.bsd3;
   mainProgram = "hlint";
-}
\ No newline at end of file
+}
diff --git a/pkgs/hnix.nix b/pkgs/hnix.nix
index ccd7a1200517a0af1d6a5eb5088aeb23d51cdfbd..f8667fde20634a0c9c996004d6587df3901e4af9 100644
--- a/pkgs/hnix.nix
+++ b/pkgs/hnix.nix
@@ -1,17 +1,75 @@
-{ mkDerivation, aeson, array, base, base16-bytestring, binary
-, bytestring, comonad, containers, criterion, cryptonite, data-fix
-, deepseq, deriving-compat, Diff, directory, exceptions, extra
-, fetchgit, filepath, free, gitrev, Glob, hashable, hashing
-, haskeline, hedgehog, hnix-store-core, hnix-store-remote
-, http-client, http-client-tls, http-types, lens-family
-, lens-family-core, lens-family-th, lib, logict, megaparsec
-, monad-control, monadlist, mtl, neat-interpolation
-, optparse-applicative, parser-combinators, pretty-show
-, prettyprinter, process, ref-tf, regex-tdfa, relude, repline
-, scientific, semialign, serialise, some, split, syb, tasty
-, tasty-hedgehog, tasty-hunit, tasty-th, template-haskell, text
-, th-lift-instances, these, time, transformers, transformers-base
-, unix-compat, unordered-containers, vector, xml
+{ mkDerivation
+, aeson
+, array
+, base
+, base16-bytestring
+, binary
+, bytestring
+, comonad
+, containers
+, criterion
+, cryptonite
+, data-fix
+, deepseq
+, deriving-compat
+, Diff
+, directory
+, exceptions
+, extra
+, fetchgit
+, filepath
+, free
+, gitrev
+, Glob
+, hashable
+, hashing
+, haskeline
+, hedgehog
+, hnix-store-core
+, hnix-store-remote
+, http-client
+, http-client-tls
+, http-types
+, lens-family
+, lens-family-core
+, lens-family-th
+, lib
+, logict
+, megaparsec
+, monad-control
+, monadlist
+, mtl
+, neat-interpolation
+, optparse-applicative
+, parser-combinators
+, pretty-show
+, prettyprinter
+, process
+, ref-tf
+, regex-tdfa
+, relude
+, repline
+, scientific
+, semialign
+, serialise
+, some
+, split
+, syb
+, tasty
+, tasty-hedgehog
+, tasty-hunit
+, tasty-th
+, template-haskell
+, text
+, th-lift-instances
+, these
+, time
+, transformers
+, transformers-base
+, unix-compat
+, unordered-containers
+, vector
+, xml
 }:
 mkDerivation {
   pname = "hnix";
@@ -25,33 +83,125 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    aeson array base base16-bytestring binary bytestring comonad
-    containers cryptonite data-fix deepseq deriving-compat directory
-    exceptions extra filepath free gitrev hashable hashing
-    hnix-store-core hnix-store-remote http-client http-client-tls
-    http-types lens-family lens-family-core lens-family-th logict
-    megaparsec monad-control monadlist mtl neat-interpolation
-    optparse-applicative parser-combinators pretty-show prettyprinter
-    process ref-tf regex-tdfa relude scientific semialign serialise
-    some split syb template-haskell text th-lift-instances these time
-    transformers transformers-base unix-compat unordered-containers
-    vector xml
+    aeson
+    array
+    base
+    base16-bytestring
+    binary
+    bytestring
+    comonad
+    containers
+    cryptonite
+    data-fix
+    deepseq
+    deriving-compat
+    directory
+    exceptions
+    extra
+    filepath
+    free
+    gitrev
+    hashable
+    hashing
+    hnix-store-core
+    hnix-store-remote
+    http-client
+    http-client-tls
+    http-types
+    lens-family
+    lens-family-core
+    lens-family-th
+    logict
+    megaparsec
+    monad-control
+    monadlist
+    mtl
+    neat-interpolation
+    optparse-applicative
+    parser-combinators
+    pretty-show
+    prettyprinter
+    process
+    ref-tf
+    regex-tdfa
+    relude
+    scientific
+    semialign
+    serialise
+    some
+    split
+    syb
+    template-haskell
+    text
+    th-lift-instances
+    these
+    time
+    transformers
+    transformers-base
+    unix-compat
+    unordered-containers
+    vector
+    xml
   ];
   executableHaskellDepends = [
-    aeson base comonad containers data-fix deepseq exceptions filepath
-    free haskeline optparse-applicative pretty-show prettyprinter
-    ref-tf relude repline serialise template-haskell time
+    aeson
+    base
+    comonad
+    containers
+    data-fix
+    deepseq
+    exceptions
+    filepath
+    free
+    haskeline
+    optparse-applicative
+    pretty-show
+    prettyprinter
+    ref-tf
+    relude
+    repline
+    serialise
+    template-haskell
+    time
   ];
   testHaskellDepends = [
-    base containers data-fix Diff directory exceptions filepath Glob
-    hedgehog megaparsec neat-interpolation optparse-applicative
-    pretty-show prettyprinter process relude serialise split tasty
-    tasty-hedgehog tasty-hunit tasty-th template-haskell time
+    base
+    containers
+    data-fix
+    Diff
+    directory
+    exceptions
+    filepath
+    Glob
+    hedgehog
+    megaparsec
+    neat-interpolation
+    optparse-applicative
+    pretty-show
+    prettyprinter
+    process
+    relude
+    serialise
+    split
+    tasty
+    tasty-hedgehog
+    tasty-hunit
+    tasty-th
+    template-haskell
+    time
     unix-compat
   ];
   benchmarkHaskellDepends = [
-    base criterion data-fix exceptions filepath optparse-applicative
-    relude serialise template-haskell time
+    base
+    criterion
+    data-fix
+    exceptions
+    filepath
+    optparse-applicative
+    relude
+    serialise
+    template-haskell
+    time
   ];
   doHaddock = false;
   jailbreak = true;
@@ -61,4 +211,4 @@ mkDerivation {
   description = "Haskell implementation of the Nix language";
   license = lib.licenses.bsd3;
   mainProgram = "hnix";
-}
\ No newline at end of file
+}
diff --git a/pkgs/hourglass.nix b/pkgs/hourglass.nix
index 155fde0ca49b2add52ceba826a6bbdbdfc8cafcc..dfe7e6932880bf6d6897522758a0e6c3b4395a22 100644
--- a/pkgs/hourglass.nix
+++ b/pkgs/hourglass.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, base, bytestring, deepseq, gauge, lib, mtl
-, old-locale, tasty, tasty-hunit, tasty-quickcheck, time
+{ mkDerivation
+, base
+, bytestring
+, deepseq
+, gauge
+, lib
+, mtl
+, old-locale
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, time
 }:
 mkDerivation {
   pname = "hourglass";
@@ -7,10 +17,23 @@ mkDerivation {
   sha256 = "44335b5c402e80c60f1db6a74462be4ea29d1a9043aa994334ffee1164f1ca4a";
   libraryHaskellDepends = [ base deepseq ];
   testHaskellDepends = [
-    base deepseq mtl old-locale tasty tasty-hunit tasty-quickcheck time
+    base
+    deepseq
+    mtl
+    old-locale
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    time
   ];
   benchmarkHaskellDepends = [
-    base bytestring deepseq gauge mtl old-locale time
+    base
+    bytestring
+    deepseq
+    gauge
+    mtl
+    old-locale
+    time
   ];
   doHaddock = false;
   jailbreak = true;
@@ -19,4 +42,4 @@ mkDerivation {
   homepage = "https://github.com/vincenthz/hs-hourglass";
   description = "simple performant time related library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/hslua-aeson.nix b/pkgs/hslua-aeson.nix
index 13ba94e963b925dde0e971248198e3243b177599..9658c7157b8133224bb97ac916638b1438fd3ead 100644
--- a/pkgs/hslua-aeson.nix
+++ b/pkgs/hslua-aeson.nix
@@ -1,20 +1,57 @@
-{ mkDerivation, aeson, base, bytestring, containers, hashable
-, hslua-core, hslua-marshalling, lib, mtl, QuickCheck
-, quickcheck-instances, scientific, tasty, tasty-quickcheck, text
-, unordered-containers, vector
+{ mkDerivation
+, aeson
+, base
+, bytestring
+, containers
+, hashable
+, hslua-core
+, hslua-marshalling
+, lib
+, mtl
+, QuickCheck
+, quickcheck-instances
+, scientific
+, tasty
+, tasty-quickcheck
+, text
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "hslua-aeson";
   version = "2.2.1";
   sha256 = "ab221cf59b915fba43deed51514a3703f7b0e504a2e26c6c787cb855bc9af545";
   libraryHaskellDepends = [
-    aeson base bytestring containers hashable hslua-core
-    hslua-marshalling mtl scientific text unordered-containers vector
+    aeson
+    base
+    bytestring
+    containers
+    hashable
+    hslua-core
+    hslua-marshalling
+    mtl
+    scientific
+    text
+    unordered-containers
+    vector
   ];
   testHaskellDepends = [
-    aeson base bytestring containers hashable hslua-core
-    hslua-marshalling mtl QuickCheck quickcheck-instances scientific
-    tasty tasty-quickcheck text unordered-containers vector
+    aeson
+    base
+    bytestring
+    containers
+    hashable
+    hslua-core
+    hslua-marshalling
+    mtl
+    QuickCheck
+    quickcheck-instances
+    scientific
+    tasty
+    tasty-quickcheck
+    text
+    unordered-containers
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -23,4 +60,4 @@ mkDerivation {
   homepage = "https://hslua.org/";
   description = "Allow aeson data types to be used with Lua";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/hspec-core.nix b/pkgs/hspec-core.nix
index 87172b4fbe2f4e42ea4791df407b3ba358ef5acd..860db35d11c5abbab00a21931fcc985e2e84bd13 100644
--- a/pkgs/hspec-core.nix
+++ b/pkgs/hspec-core.nix
@@ -1,23 +1,80 @@
-{ mkDerivation, ansi-terminal, array, base, base-orphans
-, call-stack, clock, deepseq, directory, filepath, ghc, ghc-boot-th
-, hspec-expectations, hspec-meta, HUnit, lib, process, QuickCheck
-, quickcheck-io, random, setenv, silently, stm, temporary
-, tf-random, transformers
+{ mkDerivation
+, ansi-terminal
+, array
+, base
+, base-orphans
+, call-stack
+, clock
+, deepseq
+, directory
+, filepath
+, ghc
+, ghc-boot-th
+, hspec-expectations
+, hspec-meta
+, HUnit
+, lib
+, process
+, QuickCheck
+, quickcheck-io
+, random
+, setenv
+, silently
+, stm
+, temporary
+, tf-random
+, transformers
 }:
 mkDerivation {
   pname = "hspec-core";
   version = "2.10.0.1";
   sha256 = "144b16e45019c910c857cf4c6815a1f928ded861fc7047d64e1809dd2695a93c";
   libraryHaskellDepends = [
-    ansi-terminal array base call-stack clock deepseq directory
-    filepath ghc ghc-boot-th hspec-expectations HUnit QuickCheck
-    quickcheck-io random setenv stm tf-random transformers
+    ansi-terminal
+    array
+    base
+    call-stack
+    clock
+    deepseq
+    directory
+    filepath
+    ghc
+    ghc-boot-th
+    hspec-expectations
+    HUnit
+    QuickCheck
+    quickcheck-io
+    random
+    setenv
+    stm
+    tf-random
+    transformers
   ];
   testHaskellDepends = [
-    ansi-terminal array base base-orphans call-stack clock deepseq
-    directory filepath ghc ghc-boot-th hspec-expectations hspec-meta
-    HUnit process QuickCheck quickcheck-io random setenv silently stm
-    temporary tf-random transformers
+    ansi-terminal
+    array
+    base
+    base-orphans
+    call-stack
+    clock
+    deepseq
+    directory
+    filepath
+    ghc
+    ghc-boot-th
+    hspec-expectations
+    hspec-meta
+    HUnit
+    process
+    QuickCheck
+    quickcheck-io
+    random
+    setenv
+    silently
+    stm
+    temporary
+    tf-random
+    transformers
   ];
   testToolDepends = [ hspec-meta ];
   doHaddock = false;
@@ -28,4 +85,4 @@ mkDerivation {
   homepage = "http://hspec.github.io/";
   description = "A Testing Framework for Haskell";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/hspec-discover.nix b/pkgs/hspec-discover.nix
index 528a946347e134beb3c8d39cb92fb4c39568ce71..bbcc8e0f18437e30cefee836bb406104167e32d0 100644
--- a/pkgs/hspec-discover.nix
+++ b/pkgs/hspec-discover.nix
@@ -1,4 +1,10 @@
-{ mkDerivation, base, directory, filepath, hspec-meta, lib, mockery
+{ mkDerivation
+, base
+, directory
+, filepath
+, hspec-meta
+, lib
+, mockery
 , QuickCheck
 }:
 mkDerivation {
@@ -10,7 +16,12 @@ mkDerivation {
   libraryHaskellDepends = [ base directory filepath ];
   executableHaskellDepends = [ base directory filepath ];
   testHaskellDepends = [
-    base directory filepath hspec-meta mockery QuickCheck
+    base
+    directory
+    filepath
+    hspec-meta
+    mockery
+    QuickCheck
   ];
   testToolDepends = [ hspec-meta ];
   doHaddock = false;
@@ -21,4 +32,4 @@ mkDerivation {
   description = "Automatically discover and run Hspec tests";
   license = lib.licenses.mit;
   mainProgram = "hspec-discover";
-}
\ No newline at end of file
+}
diff --git a/pkgs/hspec-meta.nix b/pkgs/hspec-meta.nix
index 802d90db601d69a20550f3482678af2a2cf2b9a0..2c745b94c51100c136f9cc7c5b5e070f952d4ef2 100644
--- a/pkgs/hspec-meta.nix
+++ b/pkgs/hspec-meta.nix
@@ -1,6 +1,22 @@
-{ mkDerivation, ansi-terminal, array, base, call-stack, clock
-, deepseq, directory, filepath, ghc, ghc-boot-th, lib, QuickCheck
-, quickcheck-io, random, setenv, stm, time, transformers
+{ mkDerivation
+, ansi-terminal
+, array
+, base
+, call-stack
+, clock
+, deepseq
+, directory
+, filepath
+, ghc
+, ghc-boot-th
+, lib
+, QuickCheck
+, quickcheck-io
+, random
+, setenv
+, stm
+, time
+, transformers
 }:
 mkDerivation {
   pname = "hspec-meta";
@@ -9,14 +25,41 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    ansi-terminal array base call-stack clock deepseq directory
-    filepath ghc ghc-boot-th QuickCheck quickcheck-io random setenv stm
-    time transformers
+    ansi-terminal
+    array
+    base
+    call-stack
+    clock
+    deepseq
+    directory
+    filepath
+    ghc
+    ghc-boot-th
+    QuickCheck
+    quickcheck-io
+    random
+    setenv
+    stm
+    time
+    transformers
   ];
   executableHaskellDepends = [
-    ansi-terminal array base call-stack clock deepseq directory
-    filepath ghc ghc-boot-th QuickCheck quickcheck-io random setenv
-    time transformers
+    ansi-terminal
+    array
+    base
+    call-stack
+    clock
+    deepseq
+    directory
+    filepath
+    ghc
+    ghc-boot-th
+    QuickCheck
+    quickcheck-io
+    random
+    setenv
+    time
+    transformers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -26,4 +69,4 @@ mkDerivation {
   description = "A version of Hspec which is used to test Hspec itself";
   license = lib.licenses.mit;
   mainProgram = "hspec-meta-discover";
-}
\ No newline at end of file
+}
diff --git a/pkgs/hspec.nix b/pkgs/hspec.nix
index 2e948f852eae79be27b4b31d5adeb4c976cf1d4c..14ba949a398a265e2a5f8e82e9b5237372a761c6 100644
--- a/pkgs/hspec.nix
+++ b/pkgs/hspec.nix
@@ -1,12 +1,21 @@
-{ mkDerivation, base, hspec-core, hspec-discover
-, hspec-expectations, lib, QuickCheck
+{ mkDerivation
+, base
+, hspec-core
+, hspec-discover
+, hspec-expectations
+, lib
+, QuickCheck
 }:
 mkDerivation {
   pname = "hspec";
   version = "2.10.3";
   sha256 = "e381944a27b5e736e514264f534218268785bcf8177d27126c68780fd9df07f2";
   libraryHaskellDepends = [
-    base hspec-core hspec-discover hspec-expectations QuickCheck
+    base
+    hspec-core
+    hspec-discover
+    hspec-expectations
+    QuickCheck
   ];
   doHaddock = false;
   jailbreak = true;
@@ -15,4 +24,4 @@ mkDerivation {
   homepage = "http://hspec.github.io/";
   description = "A Testing Framework for Haskell";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/http-client.nix b/pkgs/http-client.nix
index 2359fbaa8272f301b66909594eb3b2322aad3411..6035410e39e32eed75a073a08aee9d7c6bfaa80c 100644
--- a/pkgs/http-client.nix
+++ b/pkgs/http-client.nix
@@ -1,24 +1,85 @@
-{ mkDerivation, array, async, base, base64-bytestring
-, blaze-builder, bytestring, case-insensitive, containers, cookie
-, deepseq, directory, exceptions, filepath, ghc-prim, hspec
-, hspec-discover, http-types, iproute, lib, mime-types
-, monad-control, network, network-uri, random, stm
-, streaming-commons, text, time, transformers, zlib
+{ mkDerivation
+, array
+, async
+, base
+, base64-bytestring
+, blaze-builder
+, bytestring
+, case-insensitive
+, containers
+, cookie
+, deepseq
+, directory
+, exceptions
+, filepath
+, ghc-prim
+, hspec
+, hspec-discover
+, http-types
+, iproute
+, lib
+, mime-types
+, monad-control
+, network
+, network-uri
+, random
+, stm
+, streaming-commons
+, text
+, time
+, transformers
+, zlib
 }:
 mkDerivation {
   pname = "http-client";
   version = "0.7.13.1";
   sha256 = "c98e86a0382fa877e320d83dbbd173c41c966a60a32c9bc597058929a7aa0e27";
   libraryHaskellDepends = [
-    array async base base64-bytestring blaze-builder bytestring
-    case-insensitive containers cookie deepseq exceptions filepath
-    ghc-prim http-types iproute mime-types network network-uri random
-    stm streaming-commons text time transformers
+    array
+    async
+    base
+    base64-bytestring
+    blaze-builder
+    bytestring
+    case-insensitive
+    containers
+    cookie
+    deepseq
+    exceptions
+    filepath
+    ghc-prim
+    http-types
+    iproute
+    mime-types
+    network
+    network-uri
+    random
+    stm
+    streaming-commons
+    text
+    time
+    transformers
   ];
   testHaskellDepends = [
-    async base blaze-builder bytestring case-insensitive containers
-    cookie deepseq directory hspec http-types monad-control network
-    network-uri streaming-commons text time transformers zlib
+    async
+    base
+    blaze-builder
+    bytestring
+    case-insensitive
+    containers
+    cookie
+    deepseq
+    directory
+    hspec
+    http-types
+    monad-control
+    network
+    network-uri
+    streaming-commons
+    text
+    time
+    transformers
+    zlib
   ];
   testToolDepends = [ hspec-discover ];
   doHaddock = false;
@@ -28,4 +89,4 @@ mkDerivation {
   homepage = "https://github.com/snoyberg/http-client";
   description = "An HTTP client engine";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/http-date.nix b/pkgs/http-date.nix
index 3e9b50fd94a917be7e3e9fe5426d1011bd08e0d5..274de6271c0c578615ba16ed944ddb72cfaff723 100644
--- a/pkgs/http-date.nix
+++ b/pkgs/http-date.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, array, attoparsec, base, bytestring, doctest, hspec
-, lib, old-locale, time
+{ mkDerivation
+, array
+, attoparsec
+, base
+, bytestring
+, doctest
+, hspec
+, lib
+, old-locale
+, time
 }:
 mkDerivation {
   pname = "http-date";
@@ -7,7 +15,12 @@ mkDerivation {
   sha256 = "32f923ac1ad9bdfeadce7c52a03c9ba6225ba60dc14137cb1cdf32ea84ccf4d3";
   libraryHaskellDepends = [ array attoparsec base bytestring time ];
   testHaskellDepends = [
-    base bytestring doctest hspec old-locale time
+    base
+    bytestring
+    doctest
+    hspec
+    old-locale
+    time
   ];
   doHaddock = false;
   jailbreak = true;
@@ -15,4 +28,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "HTTP Date parser/formatter";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/http-types.nix b/pkgs/http-types.nix
index 9610e7483e76fea5ba551bab9d7b2209bd00526f..700b30164ff19a5fdd13191bf1429691d2a75304 100644
--- a/pkgs/http-types.nix
+++ b/pkgs/http-types.nix
@@ -1,15 +1,34 @@
-{ mkDerivation, array, base, bytestring, case-insensitive, doctest
-, hspec, lib, QuickCheck, quickcheck-instances, text
+{ mkDerivation
+, array
+, base
+, bytestring
+, case-insensitive
+, doctest
+, hspec
+, lib
+, QuickCheck
+, quickcheck-instances
+, text
 }:
 mkDerivation {
   pname = "http-types";
   version = "0.12.3";
   sha256 = "4e8a4a66477459fa436a331c75e46857ec8026283df984d54f90576cd3024016";
   libraryHaskellDepends = [
-    array base bytestring case-insensitive text
+    array
+    base
+    bytestring
+    case-insensitive
+    text
   ];
   testHaskellDepends = [
-    base bytestring doctest hspec QuickCheck quickcheck-instances text
+    base
+    bytestring
+    doctest
+    hspec
+    QuickCheck
+    quickcheck-instances
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +37,4 @@ mkDerivation {
   homepage = "https://github.com/aristidb/http-types";
   description = "Generic HTTP types for Haskell (for both client and server code)";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/http2.nix b/pkgs/http2.nix
index 0a312f605fbecd81f203a9be46e87582d30adfbd..f9ebd07609f4cfaf26f4bd9cca01a10a4a22aa22 100644
--- a/pkgs/http2.nix
+++ b/pkgs/http2.nix
@@ -1,9 +1,34 @@
-{ mkDerivation, aeson, aeson-pretty, array, async, base
-, base16-bytestring, bytestring, case-insensitive, containers
-, cryptonite, directory, filepath, gauge, Glob, heaps, hspec
-, hspec-discover, http-types, lib, mwc-random, network
-, network-byte-order, network-run, psqueues, stm, text
-, time-manager, typed-process, unix-time, unordered-containers
+{ mkDerivation
+, aeson
+, aeson-pretty
+, array
+, async
+, base
+, base16-bytestring
+, bytestring
+, case-insensitive
+, containers
+, cryptonite
+, directory
+, filepath
+, gauge
+, Glob
+, heaps
+, hspec
+, hspec-discover
+, http-types
+, lib
+, mwc-random
+, network
+, network-byte-order
+, network-run
+, psqueues
+, stm
+, text
+, time-manager
+, typed-process
+, unix-time
+, unordered-containers
 , vector
 }:
 mkDerivation {
@@ -13,19 +38,54 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    array async base bytestring case-insensitive containers http-types
-    network network-byte-order psqueues stm time-manager unix-time
+    array
+    async
+    base
+    bytestring
+    case-insensitive
+    containers
+    http-types
+    network
+    network-byte-order
+    psqueues
+    stm
+    time-manager
+    unix-time
   ];
   testHaskellDepends = [
-    aeson aeson-pretty async base base16-bytestring bytestring
-    cryptonite directory filepath Glob hspec http-types network
-    network-byte-order network-run text typed-process
-    unordered-containers vector
+    aeson
+    aeson-pretty
+    async
+    base
+    base16-bytestring
+    bytestring
+    cryptonite
+    directory
+    filepath
+    Glob
+    hspec
+    http-types
+    network
+    network-byte-order
+    network-run
+    text
+    typed-process
+    unordered-containers
+    vector
   ];
   testToolDepends = [ hspec-discover ];
   benchmarkHaskellDepends = [
-    array base bytestring case-insensitive containers gauge heaps
-    mwc-random network-byte-order psqueues stm
+    array
+    base
+    bytestring
+    case-insensitive
+    containers
+    gauge
+    heaps
+    mwc-random
+    network-byte-order
+    psqueues
+    stm
   ];
   doHaddock = false;
   jailbreak = true;
@@ -34,4 +94,4 @@ mkDerivation {
   homepage = "https://github.com/kazu-yamamoto/http2";
   description = "HTTP/2 library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/incipit-base.nix b/pkgs/incipit-base.nix
index 065608d875899d940162e2d08ca70fb40a19eeff..fbc82ea3526b6114bd6024ccb8261a0f1a94661e 100644
--- a/pkgs/incipit-base.nix
+++ b/pkgs/incipit-base.nix
@@ -1,12 +1,23 @@
-{ mkDerivation, base, bytestring, containers, data-default, lib
-, stm, text
+{ mkDerivation
+, base
+, bytestring
+, containers
+, data-default
+, lib
+, stm
+, text
 }:
 mkDerivation {
   pname = "incipit-base";
   version = "0.3.0.0";
   sha256 = "d12c13e0bd90276ec71595df68368cbbdaaf58ba79a171c805ec2285413ee41a";
   libraryHaskellDepends = [
-    base bytestring containers data-default stm text
+    base
+    bytestring
+    containers
+    data-default
+    stm
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -15,4 +26,4 @@ mkDerivation {
   homepage = "https://github.com/tek/incipit-core#readme";
   description = "A Prelude for Polysemy – Base Reexports";
   license = "BSD-2-Clause-Patent";
-}
\ No newline at end of file
+}
diff --git a/pkgs/incipit-core.nix b/pkgs/incipit-core.nix
index bc234d02c3b97fa0f8dfddd33401fff26a0a394a..f675befc8572debc02aed04a46019ff5c6951a7a 100644
--- a/pkgs/incipit-core.nix
+++ b/pkgs/incipit-core.nix
@@ -11,4 +11,4 @@ mkDerivation {
   homepage = "https://github.com/tek/incipit-core#readme";
   description = "A Prelude for Polysemy";
   license = "BSD-2-Clause-Patent";
-}
\ No newline at end of file
+}
diff --git a/pkgs/indexed-traversable-instances.nix b/pkgs/indexed-traversable-instances.nix
index 680b20cd07af3c0956717daadee656601d96fd94..f1dbbde4b39e6e27bc597fa5df1aaffe046fff0e 100644
--- a/pkgs/indexed-traversable-instances.nix
+++ b/pkgs/indexed-traversable-instances.nix
@@ -1,19 +1,42 @@
-{ mkDerivation, base, containers, indexed-traversable, lib
-, OneTuple, QuickCheck, quickcheck-instances, tagged, tasty
-, tasty-quickcheck, transformers, unordered-containers, vector
+{ mkDerivation
+, base
+, containers
+, indexed-traversable
+, lib
+, OneTuple
+, QuickCheck
+, quickcheck-instances
+, tagged
+, tasty
+, tasty-quickcheck
+, transformers
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "indexed-traversable-instances";
   version = "0.1.1.1";
   sha256 = "895ee5063d59e2b58930ca6fa54885bb11f19c8b7c7ba6c7b014f9431cdcc0b0";
   libraryHaskellDepends = [
-    base indexed-traversable OneTuple tagged unordered-containers
+    base
+    indexed-traversable
+    OneTuple
+    tagged
+    unordered-containers
     vector
   ];
   testHaskellDepends = [
-    base containers indexed-traversable OneTuple QuickCheck
-    quickcheck-instances tasty tasty-quickcheck transformers
-    unordered-containers vector
+    base
+    containers
+    indexed-traversable
+    OneTuple
+    QuickCheck
+    quickcheck-instances
+    tasty
+    tasty-quickcheck
+    transformers
+    unordered-containers
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -21,4 +44,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "More instances of FunctorWithIndex, FoldableWithIndex, TraversableWithIndex";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+}
diff --git a/pkgs/indexed-traversable.nix b/pkgs/indexed-traversable.nix
index 012d980d7f952e09568668ab5e520b2997cfcf28..9c51a0dfb02573c7fefc0ebbdd1f278468c54140 100644
--- a/pkgs/indexed-traversable.nix
+++ b/pkgs/indexed-traversable.nix
@@ -12,4 +12,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "FunctorWithIndex, FoldableWithIndex, TraversableWithIndex";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+}
diff --git a/pkgs/integer-logarithms.nix b/pkgs/integer-logarithms.nix
index 840e35e22b700c42da1dad072c25a61a09b65cc4..71b827789c2c4d02a77fe29b49481053fdb73dd2 100644
--- a/pkgs/integer-logarithms.nix
+++ b/pkgs/integer-logarithms.nix
@@ -1,5 +1,14 @@
-{ mkDerivation, array, base, ghc-bignum, ghc-prim, lib, QuickCheck
-, smallcheck, tasty, tasty-hunit, tasty-quickcheck
+{ mkDerivation
+, array
+, base
+, ghc-bignum
+, ghc-prim
+, lib
+, QuickCheck
+, smallcheck
+, tasty
+, tasty-hunit
+, tasty-quickcheck
 , tasty-smallcheck
 }:
 mkDerivation {
@@ -10,7 +19,12 @@ mkDerivation {
   editedCabalFile = "0z81yksgx20d0rva41blsjcp3jsp1qy9sy385fpig0l074fzv6ym";
   libraryHaskellDepends = [ array base ghc-bignum ghc-prim ];
   testHaskellDepends = [
-    base QuickCheck smallcheck tasty tasty-hunit tasty-quickcheck
+    base
+    QuickCheck
+    smallcheck
+    tasty
+    tasty-hunit
+    tasty-quickcheck
     tasty-smallcheck
   ];
   doHaddock = false;
@@ -20,4 +34,4 @@ mkDerivation {
   homepage = "https://github.com/haskellari/integer-logarithms";
   description = "Integer logarithms";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/invariant.nix b/pkgs/invariant.nix
index 47186400a0cb9afee1d657778cff1d0a7a754b08..b39f3ff85365fb16faf698d97b9a1702c7d8db6f 100644
--- a/pkgs/invariant.nix
+++ b/pkgs/invariant.nix
@@ -1,7 +1,23 @@
-{ mkDerivation, array, base, bifunctors, comonad, containers
-, contravariant, ghc-prim, hspec, hspec-discover, lib, profunctors
-, QuickCheck, StateVar, stm, tagged, template-haskell
-, th-abstraction, transformers, transformers-compat
+{ mkDerivation
+, array
+, base
+, bifunctors
+, comonad
+, containers
+, contravariant
+, ghc-prim
+, hspec
+, hspec-discover
+, lib
+, profunctors
+, QuickCheck
+, StateVar
+, stm
+, tagged
+, template-haskell
+, th-abstraction
+, transformers
+, transformers-compat
 , unordered-containers
 }:
 mkDerivation {
@@ -11,9 +27,22 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "0551ll1swnrmq09j89jqnxl4qnirbbpdpsdym23adaf36qdd7v37";
   libraryHaskellDepends = [
-    array base bifunctors comonad containers contravariant ghc-prim
-    profunctors StateVar stm tagged template-haskell th-abstraction
-    transformers transformers-compat unordered-containers
+    array
+    base
+    bifunctors
+    comonad
+    containers
+    contravariant
+    ghc-prim
+    profunctors
+    StateVar
+    stm
+    tagged
+    template-haskell
+    th-abstraction
+    transformers
+    transformers-compat
+    unordered-containers
   ];
   testHaskellDepends = [ base hspec QuickCheck template-haskell ];
   testToolDepends = [ hspec-discover ];
@@ -24,4 +53,4 @@ mkDerivation {
   homepage = "https://github.com/nfrisby/invariant-functors";
   description = "Haskell98 invariant functors";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+}
diff --git a/pkgs/iproute.nix b/pkgs/iproute.nix
index 4fdc9d68b398a83bd00c5ccbf62167674bcb70b0..85c61ab826c41cd6593293f33b861c5c0a751cc8 100644
--- a/pkgs/iproute.nix
+++ b/pkgs/iproute.nix
@@ -1,16 +1,39 @@
-{ mkDerivation, appar, base, byteorder, bytestring, containers
-, doctest, hspec, lib, network, QuickCheck, safe
+{ mkDerivation
+, appar
+, base
+, byteorder
+, bytestring
+, containers
+, doctest
+, hspec
+, lib
+, network
+, QuickCheck
+, safe
 }:
 mkDerivation {
   pname = "iproute";
   version = "1.7.12";
   sha256 = "f1751d1579fcbc1d9f86d9d1c9ede48cb71cbeb1d7b2043491c6216e4f236b63";
   libraryHaskellDepends = [
-    appar base byteorder bytestring containers network
+    appar
+    base
+    byteorder
+    bytestring
+    containers
+    network
   ];
   testHaskellDepends = [
-    appar base byteorder bytestring containers doctest hspec network
-    QuickCheck safe
+    appar
+    base
+    byteorder
+    bytestring
+    containers
+    doctest
+    hspec
+    network
+    QuickCheck
+    safe
   ];
   doHaddock = false;
   jailbreak = true;
@@ -19,4 +42,4 @@ mkDerivation {
   homepage = "http://www.mew.org/~kazu/proj/iproute/";
   description = "IP Routing Table";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/lens-aeson.nix b/pkgs/lens-aeson.nix
index 6e8b67ca7fadf5bd4c4fd31cf7714646cf0d28f2..1eabb8fd4c66a39f86bdd7f45c43f0d3018aa148 100644
--- a/pkgs/lens-aeson.nix
+++ b/pkgs/lens-aeson.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, aeson, attoparsec, base, bytestring, lens, lib
-, scientific, text, text-short, unordered-containers, vector
+{ mkDerivation
+, aeson
+, attoparsec
+, base
+, bytestring
+, lens
+, lib
+, scientific
+, text
+, text-short
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "lens-aeson";
@@ -8,8 +18,16 @@ mkDerivation {
   revision = "3";
   editedCabalFile = "0lqpl5fhl94fm3xcwf8ssz7yg9nyfxp9bw2z959x7hg6bcqmv9p1";
   libraryHaskellDepends = [
-    aeson attoparsec base bytestring lens scientific text text-short
-    unordered-containers vector
+    aeson
+    attoparsec
+    base
+    bytestring
+    lens
+    scientific
+    text
+    text-short
+    unordered-containers
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +36,4 @@ mkDerivation {
   homepage = "http://github.com/lens/lens-aeson/";
   description = "Law-abiding lenses for aeson";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/lens-family-th.nix b/pkgs/lens-family-th.nix
index 72dc5855ebe9ff4e27a3a5ebbc611dee4b151cbd..4c740b22e6f99e7d149ec8e96f09a37d06168bf7 100644
--- a/pkgs/lens-family-th.nix
+++ b/pkgs/lens-family-th.nix
@@ -12,4 +12,4 @@ mkDerivation {
   homepage = "http://github.com/DanBurton/lens-family-th#readme";
   description = "Generate lens-family style lenses";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/lens.nix b/pkgs/lens.nix
index ab6ed3d17f1ace7ca89ffb234b618c1c259e81b0..d994a55f007b2fdc7cc2309f8c2f60a7c32e4eab 100644
--- a/pkgs/lens.nix
+++ b/pkgs/lens.nix
@@ -1,35 +1,115 @@
-{ mkDerivation, array, assoc, base, base-compat, base-orphans
-, bifunctors, bytestring, call-stack, comonad, containers
-, contravariant, criterion, deepseq, distributive, exceptions
-, filepath, free, generic-deriving, ghc-prim, hashable, HUnit
-, indexed-traversable, indexed-traversable-instances
-, kan-extensions, lib, mtl, parallel, profunctors, QuickCheck
-, reflection, semigroupoids, simple-reflect, strict, tagged
-, template-haskell, test-framework, test-framework-hunit
-, test-framework-quickcheck2, text, th-abstraction, these
-, transformers, transformers-compat, unordered-containers, vector
+{ mkDerivation
+, array
+, assoc
+, base
+, base-compat
+, base-orphans
+, bifunctors
+, bytestring
+, call-stack
+, comonad
+, containers
+, contravariant
+, criterion
+, deepseq
+, distributive
+, exceptions
+, filepath
+, free
+, generic-deriving
+, ghc-prim
+, hashable
+, HUnit
+, indexed-traversable
+, indexed-traversable-instances
+, kan-extensions
+, lib
+, mtl
+, parallel
+, profunctors
+, QuickCheck
+, reflection
+, semigroupoids
+, simple-reflect
+, strict
+, tagged
+, template-haskell
+, test-framework
+, test-framework-hunit
+, test-framework-quickcheck2
+, text
+, th-abstraction
+, these
+, transformers
+, transformers-compat
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "lens";
   version = "5.2";
   sha256 = "b33e2ebede468d9e8acb79d20bb5a5947fc3bec13cc39b122aa131c5e6dcd188";
   libraryHaskellDepends = [
-    array assoc base base-orphans bifunctors bytestring call-stack
-    comonad containers contravariant distributive exceptions filepath
-    free ghc-prim hashable indexed-traversable
-    indexed-traversable-instances kan-extensions mtl parallel
-    profunctors reflection semigroupoids strict tagged template-haskell
-    text th-abstraction these transformers transformers-compat
-    unordered-containers vector
+    array
+    assoc
+    base
+    base-orphans
+    bifunctors
+    bytestring
+    call-stack
+    comonad
+    containers
+    contravariant
+    distributive
+    exceptions
+    filepath
+    free
+    ghc-prim
+    hashable
+    indexed-traversable
+    indexed-traversable-instances
+    kan-extensions
+    mtl
+    parallel
+    profunctors
+    reflection
+    semigroupoids
+    strict
+    tagged
+    template-haskell
+    text
+    th-abstraction
+    these
+    transformers
+    transformers-compat
+    unordered-containers
+    vector
   ];
   testHaskellDepends = [
-    base containers deepseq HUnit mtl QuickCheck simple-reflect
-    test-framework test-framework-hunit test-framework-quickcheck2
+    base
+    containers
+    deepseq
+    HUnit
+    mtl
+    QuickCheck
+    simple-reflect
+    test-framework
+    test-framework-hunit
+    test-framework-quickcheck2
     transformers
   ];
   benchmarkHaskellDepends = [
-    base base-compat bytestring comonad containers criterion deepseq
-    generic-deriving transformers unordered-containers vector
+    base
+    base-compat
+    bytestring
+    comonad
+    containers
+    criterion
+    deepseq
+    generic-deriving
+    transformers
+    unordered-containers
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -38,4 +118,4 @@ mkDerivation {
   homepage = "http://github.com/ekmett/lens/";
   description = "Lenses, Folds and Traversals";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+}
diff --git a/pkgs/lifted-async.nix b/pkgs/lifted-async.nix
index 5ed02c8f7b96a01da1d22c6d32716cd56e0e41d2..35714f6c8e7f788796d158a3d43fb35f07b9f11f 100644
--- a/pkgs/lifted-async.nix
+++ b/pkgs/lifted-async.nix
@@ -1,17 +1,43 @@
-{ mkDerivation, async, base, constraints, deepseq, HUnit, lib
-, lifted-base, monad-control, mtl, tasty, tasty-bench
-, tasty-expected-failure, tasty-hunit, tasty-th, transformers-base
+{ mkDerivation
+, async
+, base
+, constraints
+, deepseq
+, HUnit
+, lib
+, lifted-base
+, monad-control
+, mtl
+, tasty
+, tasty-bench
+, tasty-expected-failure
+, tasty-hunit
+, tasty-th
+, transformers-base
 }:
 mkDerivation {
   pname = "lifted-async";
   version = "0.10.2.1";
   sha256 = "0d05715f44bb5464f97bac46302a81338271375b07c54c90efb33b1c0e298e48";
   libraryHaskellDepends = [
-    async base constraints lifted-base monad-control transformers-base
+    async
+    base
+    constraints
+    lifted-base
+    monad-control
+    transformers-base
   ];
   testHaskellDepends = [
-    async base HUnit lifted-base monad-control mtl tasty
-    tasty-expected-failure tasty-hunit tasty-th
+    async
+    base
+    HUnit
+    lifted-base
+    monad-control
+    mtl
+    tasty
+    tasty-expected-failure
+    tasty-hunit
+    tasty-th
   ];
   benchmarkHaskellDepends = [ async base deepseq tasty-bench ];
   doHaddock = false;
@@ -21,4 +47,4 @@ mkDerivation {
   homepage = "https://github.com/maoe/lifted-async";
   description = "Run lifted IO operations asynchronously and wait for their results";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/linear.nix b/pkgs/linear.nix
index f1429d0c9a07e1643f0c5fcbc2f383cdde79cafc..7f14b8dc41ccf8fca3acce38ab4ccda87e32d39a 100644
--- a/pkgs/linear.nix
+++ b/pkgs/linear.nix
@@ -1,9 +1,33 @@
-{ mkDerivation, adjunctions, base, base-orphans, binary, bytes
-, bytestring, cereal, containers, deepseq, distributive, ghc-prim
-, hashable, HUnit, indexed-traversable, lens, lib, random
-, reflection, semigroupoids, semigroups, simple-reflect, tagged
-, template-haskell, test-framework, test-framework-hunit
-, transformers, transformers-compat, unordered-containers, vector
+{ mkDerivation
+, adjunctions
+, base
+, base-orphans
+, binary
+, bytes
+, bytestring
+, cereal
+, containers
+, deepseq
+, distributive
+, ghc-prim
+, hashable
+, HUnit
+, indexed-traversable
+, lens
+, lib
+, random
+, reflection
+, semigroupoids
+, semigroups
+, simple-reflect
+, tagged
+, template-haskell
+, test-framework
+, test-framework-hunit
+, transformers
+, transformers-compat
+, unordered-containers
+, vector
 , void
 }:
 mkDerivation {
@@ -11,14 +35,42 @@ mkDerivation {
   version = "1.21.10";
   sha256 = "b90733227c9d4047e087a0083785e8293dc623169161c6dab12ece1ac90d7ab4";
   libraryHaskellDepends = [
-    adjunctions base base-orphans binary bytes cereal containers
-    deepseq distributive ghc-prim hashable indexed-traversable lens
-    random reflection semigroupoids semigroups tagged template-haskell
-    transformers transformers-compat unordered-containers vector void
+    adjunctions
+    base
+    base-orphans
+    binary
+    bytes
+    cereal
+    containers
+    deepseq
+    distributive
+    ghc-prim
+    hashable
+    indexed-traversable
+    lens
+    random
+    reflection
+    semigroupoids
+    semigroups
+    tagged
+    template-haskell
+    transformers
+    transformers-compat
+    unordered-containers
+    vector
+    void
   ];
   testHaskellDepends = [
-    base binary bytestring deepseq HUnit reflection simple-reflect
-    test-framework test-framework-hunit vector
+    base
+    binary
+    bytestring
+    deepseq
+    HUnit
+    reflection
+    simple-reflect
+    test-framework
+    test-framework-hunit
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -27,4 +79,4 @@ mkDerivation {
   homepage = "http://github.com/ekmett/linear/";
   description = "Linear Algebra";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/lsp-types.nix b/pkgs/lsp-types.nix
index 42f0fab0800f62e7992e98b622187f301e8f21d2..25eda49a48d99f1c8398795edb92053b27841883 100644
--- a/pkgs/lsp-types.nix
+++ b/pkgs/lsp-types.nix
@@ -1,21 +1,70 @@
-{ mkDerivation, aeson, base, binary, containers, data-default
-, deepseq, Diff, dlist, exceptions, filepath, hashable, hspec
-, hspec-discover, lens, lib, mod, mtl, network-uri, QuickCheck
-, quickcheck-instances, safe, scientific, some, template-haskell
-, text, tuple, unordered-containers
+{ mkDerivation
+, aeson
+, base
+, binary
+, containers
+, data-default
+, deepseq
+, Diff
+, dlist
+, exceptions
+, filepath
+, hashable
+, hspec
+, hspec-discover
+, lens
+, lib
+, mod
+, mtl
+, network-uri
+, QuickCheck
+, quickcheck-instances
+, safe
+, scientific
+, some
+, template-haskell
+, text
+, tuple
+, unordered-containers
 }:
 mkDerivation {
   pname = "lsp-types";
   version = "1.6.0.0";
   sha256 = "385dc4fb3c7fcdb5c6cb26cf9f589b879cdb28dc7a452a6dc628dec369c19802";
   libraryHaskellDepends = [
-    aeson base binary containers data-default deepseq Diff dlist
-    exceptions filepath hashable lens mod mtl network-uri safe
-    scientific some template-haskell text unordered-containers
+    aeson
+    base
+    binary
+    containers
+    data-default
+    deepseq
+    Diff
+    dlist
+    exceptions
+    filepath
+    hashable
+    lens
+    mod
+    mtl
+    network-uri
+    safe
+    scientific
+    some
+    template-haskell
+    text
+    unordered-containers
   ];
   testHaskellDepends = [
-    aeson base filepath hspec lens network-uri QuickCheck
-    quickcheck-instances text tuple
+    aeson
+    base
+    filepath
+    hspec
+    lens
+    network-uri
+    QuickCheck
+    quickcheck-instances
+    text
+    tuple
   ];
   testToolDepends = [ hspec-discover ];
   doHaddock = false;
@@ -25,4 +74,4 @@ mkDerivation {
   homepage = "https://github.com/haskell/lsp";
   description = "Haskell library for the Microsoft Language Server Protocol, data types";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/lsp.nix b/pkgs/lsp.nix
index 7fa8e8b65fa60efc03a63f6c2d42435bf9063cde..154933c0838d9ec36caac7ce7468a47f1867841e 100644
--- a/pkgs/lsp.nix
+++ b/pkgs/lsp.nix
@@ -1,8 +1,32 @@
-{ mkDerivation, aeson, async, attoparsec, base, bytestring
-, co-log-core, containers, data-default, directory, exceptions
-, filepath, hashable, hspec, hspec-discover, lens, lib, lsp-types
-, mtl, prettyprinter, random, sorted-list, stm, temporary, text
-, text-rope, transformers, unliftio-core, unordered-containers
+{ mkDerivation
+, aeson
+, async
+, attoparsec
+, base
+, bytestring
+, co-log-core
+, containers
+, data-default
+, directory
+, exceptions
+, filepath
+, hashable
+, hspec
+, hspec-discover
+, lens
+, lib
+, lsp-types
+, mtl
+, prettyprinter
+, random
+, sorted-list
+, stm
+, temporary
+, text
+, text-rope
+, transformers
+, unliftio-core
+, unordered-containers
 , uuid
 }:
 mkDerivation {
@@ -12,13 +36,40 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    aeson async attoparsec base bytestring co-log-core containers
-    data-default directory exceptions filepath hashable lens lsp-types
-    mtl prettyprinter random sorted-list stm temporary text text-rope
-    transformers unliftio-core unordered-containers uuid
+    aeson
+    async
+    attoparsec
+    base
+    bytestring
+    co-log-core
+    containers
+    data-default
+    directory
+    exceptions
+    filepath
+    hashable
+    lens
+    lsp-types
+    mtl
+    prettyprinter
+    random
+    sorted-list
+    stm
+    temporary
+    text
+    text-rope
+    transformers
+    unliftio-core
+    unordered-containers
+    uuid
   ];
   testHaskellDepends = [
-    base containers hspec sorted-list text text-rope
+    base
+    containers
+    hspec
+    sorted-list
+    text
+    text-rope
     unordered-containers
   ];
   testToolDepends = [ hspec-discover ];
@@ -29,4 +80,4 @@ mkDerivation {
   homepage = "https://github.com/haskell/lsp";
   description = "Haskell library for the Microsoft Language Server Protocol";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/lucid.nix b/pkgs/lucid.nix
index c95b1d30724e943ebdff365c72d17af6e34bc6c8..67cb551b583f33946812a862cb8a74b99aaa07d9 100644
--- a/pkgs/lucid.nix
+++ b/pkgs/lucid.nix
@@ -1,6 +1,20 @@
-{ mkDerivation, base, bifunctors, blaze-builder, bytestring
-, containers, criterion, deepseq, hashable, hspec, HUnit, lib
-, mmorph, mtl, parsec, text, transformers
+{ mkDerivation
+, base
+, bifunctors
+, blaze-builder
+, bytestring
+, containers
+, criterion
+, deepseq
+, hashable
+, hspec
+, HUnit
+, lib
+, mmorph
+, mtl
+, parsec
+, text
+, transformers
 }:
 mkDerivation {
   pname = "lucid";
@@ -9,14 +23,33 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "0wipmh3xcs00x8lbq5j780rdc2klfj67nzni21qc1pdbhr2whn9d";
   libraryHaskellDepends = [
-    base blaze-builder bytestring containers hashable mmorph mtl text
+    base
+    blaze-builder
+    bytestring
+    containers
+    hashable
+    mmorph
+    mtl
+    text
     transformers
   ];
   testHaskellDepends = [
-    base bifunctors hspec HUnit mtl parsec text
+    base
+    bifunctors
+    hspec
+    HUnit
+    mtl
+    parsec
+    text
   ];
   benchmarkHaskellDepends = [
-    base blaze-builder bytestring criterion deepseq text transformers
+    base
+    blaze-builder
+    bytestring
+    criterion
+    deepseq
+    text
+    transformers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -25,4 +58,4 @@ mkDerivation {
   homepage = "https://github.com/chrisdone/lucid";
   description = "Clear to write, read and edit DSL for HTML";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/memory.nix b/pkgs/memory.nix
index bb9ab81604d092bde13b2bff0fed247ff9fafd1e..9b382e769e7f4b9b392fa07513553eecbe68638f 100644
--- a/pkgs/memory.nix
+++ b/pkgs/memory.nix
@@ -1,12 +1,22 @@
-{ mkDerivation, base, basement, bytestring, deepseq, foundation
-, ghc-prim, lib
+{ mkDerivation
+, base
+, basement
+, bytestring
+, deepseq
+, foundation
+, ghc-prim
+, lib
 }:
 mkDerivation {
   pname = "memory";
   version = "0.18.0";
   sha256 = "fd4eb6f638e24b81b4e6cdd68772a531726f2f67686c8969d3407d82f7862e3e";
   libraryHaskellDepends = [
-    base basement bytestring deepseq ghc-prim
+    base
+    basement
+    bytestring
+    deepseq
+    ghc-prim
   ];
   testHaskellDepends = [ base basement bytestring foundation ];
   doHaddock = false;
@@ -16,4 +26,4 @@ mkDerivation {
   homepage = "https://github.com/vincenthz/hs-memory";
   description = "memory and related abstraction stuff";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/monoid-subclasses.nix b/pkgs/monoid-subclasses.nix
index 5bcd277da32adde5bd5394d783917f05d5f2fc7e..f3d7815ecea61580bc26f3000965b6cd2b94060e 100644
--- a/pkgs/monoid-subclasses.nix
+++ b/pkgs/monoid-subclasses.nix
@@ -1,5 +1,14 @@
-{ mkDerivation, base, bytestring, containers, lib, primes
-, QuickCheck, quickcheck-instances, tasty, tasty-quickcheck, text
+{ mkDerivation
+, base
+, bytestring
+, containers
+, lib
+, primes
+, QuickCheck
+, quickcheck-instances
+, tasty
+, tasty-quickcheck
+, text
 , vector
 }:
 mkDerivation {
@@ -9,11 +18,24 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "0y8sw3zsmz5ssn2gl2fsqg44n7xf3xsf6vhrzwnkbaa97hj76nh2";
   libraryHaskellDepends = [
-    base bytestring containers primes text vector
+    base
+    bytestring
+    containers
+    primes
+    text
+    vector
   ];
   testHaskellDepends = [
-    base bytestring containers primes QuickCheck quickcheck-instances
-    tasty tasty-quickcheck text vector
+    base
+    bytestring
+    containers
+    primes
+    QuickCheck
+    quickcheck-instances
+    tasty
+    tasty-quickcheck
+    text
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -22,4 +44,4 @@ mkDerivation {
   homepage = "https://github.com/blamario/monoid-subclasses/";
   description = "Subclasses of Monoid";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/net-mqtt.nix b/pkgs/net-mqtt.nix
index 0cc65a08cdb9ff02e07f3c827536e9ef1b3f3152..60506e290fb01fb7079812f8de1672799ca68b4a 100644
--- a/pkgs/net-mqtt.nix
+++ b/pkgs/net-mqtt.nix
@@ -1,8 +1,28 @@
-{ mkDerivation, async, attoparsec, attoparsec-binary, base, binary
-, bytestring, checkers, conduit, conduit-extra, connection
-, containers, deepseq, HUnit, lib, network-conduit-tls, network-uri
-, optparse-applicative, QuickCheck, stm, tasty, tasty-hunit
-, tasty-quickcheck, text, websockets
+{ mkDerivation
+, async
+, attoparsec
+, attoparsec-binary
+, base
+, binary
+, bytestring
+, checkers
+, conduit
+, conduit-extra
+, connection
+, containers
+, deepseq
+, HUnit
+, lib
+, network-conduit-tls
+, network-uri
+, optparse-applicative
+, QuickCheck
+, stm
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, text
+, websockets
 }:
 mkDerivation {
   pname = "net-mqtt";
@@ -11,20 +31,67 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    async attoparsec attoparsec-binary base binary bytestring conduit
-    conduit-extra connection containers deepseq network-conduit-tls
-    network-uri QuickCheck stm text websockets
+    async
+    attoparsec
+    attoparsec-binary
+    base
+    binary
+    bytestring
+    conduit
+    conduit-extra
+    connection
+    containers
+    deepseq
+    network-conduit-tls
+    network-uri
+    QuickCheck
+    stm
+    text
+    websockets
   ];
   executableHaskellDepends = [
-    async attoparsec attoparsec-binary base binary bytestring conduit
-    conduit-extra connection containers deepseq network-conduit-tls
-    network-uri optparse-applicative QuickCheck stm text websockets
+    async
+    attoparsec
+    attoparsec-binary
+    base
+    binary
+    bytestring
+    conduit
+    conduit-extra
+    connection
+    containers
+    deepseq
+    network-conduit-tls
+    network-uri
+    optparse-applicative
+    QuickCheck
+    stm
+    text
+    websockets
   ];
   testHaskellDepends = [
-    async attoparsec attoparsec-binary base binary bytestring checkers
-    conduit conduit-extra connection containers deepseq HUnit
-    network-conduit-tls network-uri QuickCheck stm tasty tasty-hunit
-    tasty-quickcheck text websockets
+    async
+    attoparsec
+    attoparsec-binary
+    base
+    binary
+    bytestring
+    checkers
+    conduit
+    conduit-extra
+    connection
+    containers
+    deepseq
+    HUnit
+    network-conduit-tls
+    network-uri
+    QuickCheck
+    stm
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    text
+    websockets
   ];
   doHaddock = false;
   jailbreak = true;
@@ -33,4 +100,4 @@ mkDerivation {
   homepage = "https://github.com/dustin/mqtt-hs#readme";
   description = "An MQTT Protocol Implementation";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/network-byte-order.nix b/pkgs/network-byte-order.nix
index 7c69f379538ba7d87d701221c04e20e9752baa2c..696506cb012de2b0cb5034f9de8b9297a8fda33c 100644
--- a/pkgs/network-byte-order.nix
+++ b/pkgs/network-byte-order.nix
@@ -13,4 +13,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Network byte order utilities";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/newtype-generics.nix b/pkgs/newtype-generics.nix
index e4b6b544a2bf503c54cfcdcc7bdef6b1389e4fee..acd3f35a9568f3c9203b5f26d5c7f4b4a074b72e 100644
--- a/pkgs/newtype-generics.nix
+++ b/pkgs/newtype-generics.nix
@@ -1,4 +1,10 @@
-{ mkDerivation, base, gauge, hspec, hspec-discover, lib, semigroups
+{ mkDerivation
+, base
+, gauge
+, hspec
+, hspec-discover
+, lib
+, semigroups
 }:
 mkDerivation {
   pname = "newtype-generics";
@@ -17,4 +23,4 @@ mkDerivation {
   homepage = "http://github.com/sjakobi/newtype-generics";
   description = "A typeclass and set of functions for working with newtypes";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/nothunks.nix b/pkgs/nothunks.nix
index b7680751ea8924c7089258f197429966d8097155..c8d482b43249b956e4d2512ba677edd5ab8089c6 100644
--- a/pkgs/nothunks.nix
+++ b/pkgs/nothunks.nix
@@ -1,5 +1,17 @@
-{ mkDerivation, base, bytestring, containers, ghc-heap, ghc-prim
-, hedgehog, lib, random, stm, tasty, tasty-hedgehog, text, time
+{ mkDerivation
+, base
+, bytestring
+, containers
+, ghc-heap
+, ghc-prim
+, hedgehog
+, lib
+, random
+, stm
+, tasty
+, tasty-hedgehog
+, text
+, time
 , vector
 }:
 mkDerivation {
@@ -7,10 +19,24 @@ mkDerivation {
   version = "0.1.3";
   sha256 = "c191e9c3d86ca006bf8d85adfd936ff997759120b0fcfaf4960a56d8bd850e53";
   libraryHaskellDepends = [
-    base bytestring containers ghc-heap stm text time vector
+    base
+    bytestring
+    containers
+    ghc-heap
+    stm
+    text
+    time
+    vector
   ];
   testHaskellDepends = [
-    base containers ghc-prim hedgehog random stm tasty tasty-hedgehog
+    base
+    containers
+    ghc-prim
+    hedgehog
+    random
+    stm
+    tasty
+    tasty-hedgehog
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +44,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Examine values for unexpected thunks";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/optics-core.nix b/pkgs/optics-core.nix
index ffde65507cc0127ac2a02af95a9b5800f0ad610a..e67aa7cbac1996b5da363233b402fe0f64fc9344 100644
--- a/pkgs/optics-core.nix
+++ b/pkgs/optics-core.nix
@@ -1,5 +1,11 @@
-{ mkDerivation, array, base, containers, indexed-profunctors
-, indexed-traversable, lib, transformers
+{ mkDerivation
+, array
+, base
+, containers
+, indexed-profunctors
+, indexed-traversable
+, lib
+, transformers
 }:
 mkDerivation {
   pname = "optics-core";
@@ -8,7 +14,11 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "0sqwlbl6x0197bpkq7jvn9j5iwyr54z8qwmxbij6qlwjyfld2qxi";
   libraryHaskellDepends = [
-    array base containers indexed-profunctors indexed-traversable
+    array
+    base
+    containers
+    indexed-profunctors
+    indexed-traversable
     transformers
   ];
   doHaddock = false;
@@ -17,4 +27,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Optics as an abstract interface: core definitions";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/optics-extra.nix b/pkgs/optics-extra.nix
index fe269de613200b3fb2bab326889c5fbe9ba318a1..f24ad183e9679c9c56e2e6b4892dbbd0d5097f84 100644
--- a/pkgs/optics-extra.nix
+++ b/pkgs/optics-extra.nix
@@ -1,6 +1,18 @@
-{ mkDerivation, array, base, bytestring, containers, hashable
-, indexed-profunctors, indexed-traversable-instances, lib, mtl
-, optics-core, text, transformers, unordered-containers, vector
+{ mkDerivation
+, array
+, base
+, bytestring
+, containers
+, hashable
+, indexed-profunctors
+, indexed-traversable-instances
+, lib
+, mtl
+, optics-core
+, text
+, transformers
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "optics-extra";
@@ -9,9 +21,19 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "0bpr1bkb7mmww028n8ikwa0qhdl7ybxpb9s887dlp3dvxr5iq8nq";
   libraryHaskellDepends = [
-    array base bytestring containers hashable indexed-profunctors
-    indexed-traversable-instances mtl optics-core text transformers
-    unordered-containers vector
+    array
+    base
+    bytestring
+    containers
+    hashable
+    indexed-profunctors
+    indexed-traversable-instances
+    mtl
+    optics-core
+    text
+    transformers
+    unordered-containers
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -19,4 +41,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Extra utilities and instances for optics-core";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/optics-th.nix b/pkgs/optics-th.nix
index 7549806af4f0daef2b7c070b42a0acd5757ee6fc..c95ee757bf31e12b9a932c6eece3746ad182dfd1 100644
--- a/pkgs/optics-th.nix
+++ b/pkgs/optics-th.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, base, containers, lib, mtl, optics-core, tagged
-, template-haskell, th-abstraction, transformers
+{ mkDerivation
+, base
+, containers
+, lib
+, mtl
+, optics-core
+, tagged
+, template-haskell
+, th-abstraction
+, transformers
 }:
 mkDerivation {
   pname = "optics-th";
@@ -8,7 +16,12 @@ mkDerivation {
   revision = "2";
   editedCabalFile = "1fl217q7s0g8a46p2smanhhdj0jqvc9n3lagcnpphkv3fzfgrcbz";
   libraryHaskellDepends = [
-    base containers mtl optics-core template-haskell th-abstraction
+    base
+    containers
+    mtl
+    optics-core
+    template-haskell
+    th-abstraction
     transformers
   ];
   testHaskellDepends = [ base optics-core tagged ];
@@ -18,4 +31,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Optics construction using TemplateHaskell";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/optics.nix b/pkgs/optics.nix
index 79c9ec9eec9bd86793a196c79d88d1dfc39a6c11..e155925209ec7ba32466ae5c63b1b561963e388f 100644
--- a/pkgs/optics.nix
+++ b/pkgs/optics.nix
@@ -1,25 +1,64 @@
-{ mkDerivation, array, base, bytestring, containers
-, indexed-profunctors, inspection-testing, lens, lib, mtl
-, optics-core, optics-extra, optics-th, QuickCheck, random, tasty
-, tasty-bench, tasty-hunit, tasty-quickcheck, template-haskell
-, transformers, unordered-containers, vector
+{ mkDerivation
+, array
+, base
+, bytestring
+, containers
+, indexed-profunctors
+, inspection-testing
+, lens
+, lib
+, mtl
+, optics-core
+, optics-extra
+, optics-th
+, QuickCheck
+, random
+, tasty
+, tasty-bench
+, tasty-hunit
+, tasty-quickcheck
+, template-haskell
+, transformers
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "optics";
   version = "0.4.2";
   sha256 = "ebe7553704d3491f02777dc6f02a2cf170d4b87ce5265139ce759314460533c7";
   libraryHaskellDepends = [
-    array base containers mtl optics-core optics-extra optics-th
+    array
+    base
+    containers
+    mtl
+    optics-core
+    optics-extra
+    optics-th
     transformers
   ];
   testHaskellDepends = [
-    base containers indexed-profunctors inspection-testing mtl
-    optics-core QuickCheck random tasty tasty-hunit tasty-quickcheck
+    base
+    containers
+    indexed-profunctors
+    inspection-testing
+    mtl
+    optics-core
+    QuickCheck
+    random
+    tasty
+    tasty-hunit
+    tasty-quickcheck
     template-haskell
   ];
   benchmarkHaskellDepends = [
-    base bytestring containers lens tasty-bench transformers
-    unordered-containers vector
+    base
+    bytestring
+    containers
+    lens
+    tasty-bench
+    transformers
+    unordered-containers
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -27,4 +66,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Optics as an abstract interface";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/pandoc.nix b/pkgs/pandoc.nix
index a50c35296180e1495b3edff8beee7f01ddb9eab0..7b22c189bc18ee82c9895f986038a0e571df6ecd 100644
--- a/pkgs/pandoc.nix
+++ b/pkgs/pandoc.nix
@@ -1,20 +1,91 @@
-{ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
-, base64, binary, blaze-html, blaze-markup, bytestring
-, case-insensitive, citeproc, commonmark, commonmark-extensions
-, commonmark-pandoc, connection, containers, data-default, deepseq
-, Diff, directory, doclayout, doctemplates, emojis, exceptions
-, file-embed, filepath, Glob, gridtables, haddock-library, hslua
-, hslua-aeson, hslua-module-doclayout, hslua-module-path
-, hslua-module-system, hslua-module-text, hslua-module-version
-, http-client, http-client-tls, http-types, ipynb, jira-wiki-markup
-, JuicyPixels, lib, lpeg, mtl, network, network-uri
-, pandoc-lua-marshal, pandoc-types, parsec, pretty, pretty-show
-, process, random, safe, scientific, servant-server, SHA
-, skylighting, skylighting-core, split, syb, tagsoup, tasty
-, tasty-bench, tasty-golden, tasty-hunit, tasty-lua
-, tasty-quickcheck, temporary, texmath, text, text-conversions
-, time, unicode-collation, unicode-transforms, unix, wai, wai-extra
-, warp, xml, xml-conduit, xml-types, yaml, zip-archive, zlib
+{ mkDerivation
+, aeson
+, aeson-pretty
+, array
+, attoparsec
+, base
+, base64
+, binary
+, blaze-html
+, blaze-markup
+, bytestring
+, case-insensitive
+, citeproc
+, commonmark
+, commonmark-extensions
+, commonmark-pandoc
+, connection
+, containers
+, data-default
+, deepseq
+, Diff
+, directory
+, doclayout
+, doctemplates
+, emojis
+, exceptions
+, file-embed
+, filepath
+, Glob
+, gridtables
+, haddock-library
+, hslua
+, hslua-aeson
+, hslua-module-doclayout
+, hslua-module-path
+, hslua-module-system
+, hslua-module-text
+, hslua-module-version
+, http-client
+, http-client-tls
+, http-types
+, ipynb
+, jira-wiki-markup
+, JuicyPixels
+, lib
+, lpeg
+, mtl
+, network
+, network-uri
+, pandoc-lua-marshal
+, pandoc-types
+, parsec
+, pretty
+, pretty-show
+, process
+, random
+, safe
+, scientific
+, servant-server
+, SHA
+, skylighting
+, skylighting-core
+, split
+, syb
+, tagsoup
+, tasty
+, tasty-bench
+, tasty-golden
+, tasty-hunit
+, tasty-lua
+, tasty-quickcheck
+, temporary
+, texmath
+, text
+, text-conversions
+, time
+, unicode-collation
+, unicode-transforms
+, unix
+, wai
+, wai-extra
+, warp
+, xml
+, xml-conduit
+, xml-types
+, yaml
+, zip-archive
+, zlib
 }:
 mkDerivation {
   pname = "pandoc";
@@ -25,29 +96,116 @@ mkDerivation {
   isExecutable = true;
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
-    aeson aeson-pretty array attoparsec base base64 binary blaze-html
-    blaze-markup bytestring case-insensitive citeproc commonmark
-    commonmark-extensions commonmark-pandoc connection containers
-    data-default deepseq directory doclayout doctemplates emojis
-    exceptions file-embed filepath Glob gridtables haddock-library
-    hslua hslua-aeson hslua-module-doclayout hslua-module-path
-    hslua-module-system hslua-module-text hslua-module-version
-    http-client http-client-tls http-types ipynb jira-wiki-markup
-    JuicyPixels lpeg mtl network network-uri pandoc-lua-marshal
-    pandoc-types parsec pretty pretty-show process random safe
-    scientific servant-server SHA skylighting skylighting-core split
-    syb tagsoup temporary texmath text text-conversions time
-    unicode-collation unicode-transforms unix wai xml xml-conduit
-    xml-types yaml zip-archive zlib
+    aeson
+    aeson-pretty
+    array
+    attoparsec
+    base
+    base64
+    binary
+    blaze-html
+    blaze-markup
+    bytestring
+    case-insensitive
+    citeproc
+    commonmark
+    commonmark-extensions
+    commonmark-pandoc
+    connection
+    containers
+    data-default
+    deepseq
+    directory
+    doclayout
+    doctemplates
+    emojis
+    exceptions
+    file-embed
+    filepath
+    Glob
+    gridtables
+    haddock-library
+    hslua
+    hslua-aeson
+    hslua-module-doclayout
+    hslua-module-path
+    hslua-module-system
+    hslua-module-text
+    hslua-module-version
+    http-client
+    http-client-tls
+    http-types
+    ipynb
+    jira-wiki-markup
+    JuicyPixels
+    lpeg
+    mtl
+    network
+    network-uri
+    pandoc-lua-marshal
+    pandoc-types
+    parsec
+    pretty
+    pretty-show
+    process
+    random
+    safe
+    scientific
+    servant-server
+    SHA
+    skylighting
+    skylighting-core
+    split
+    syb
+    tagsoup
+    temporary
+    texmath
+    text
+    text-conversions
+    time
+    unicode-collation
+    unicode-transforms
+    unix
+    wai
+    xml
+    xml-conduit
+    xml-types
+    yaml
+    zip-archive
+    zlib
   ];
   executableHaskellDepends = [ base safe wai-extra warp ];
   testHaskellDepends = [
-    base bytestring containers Diff directory doctemplates exceptions
-    filepath Glob hslua mtl pandoc-types process tasty tasty-golden
-    tasty-hunit tasty-lua tasty-quickcheck text time xml zip-archive
+    base
+    bytestring
+    containers
+    Diff
+    directory
+    doctemplates
+    exceptions
+    filepath
+    Glob
+    hslua
+    mtl
+    pandoc-types
+    process
+    tasty
+    tasty-golden
+    tasty-hunit
+    tasty-lua
+    tasty-quickcheck
+    text
+    time
+    xml
+    zip-archive
   ];
   benchmarkHaskellDepends = [
-    base bytestring deepseq mtl tasty-bench text
+    base
+    bytestring
+    deepseq
+    mtl
+    tasty-bench
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -61,4 +219,4 @@ mkDerivation {
   description = "Conversion between markup formats";
   license = lib.licenses.gpl2Plus;
   mainProgram = "pandoc";
-}
\ No newline at end of file
+}
diff --git a/pkgs/parallel.nix b/pkgs/parallel.nix
index 7eb81fdac65507bf2b2e4b9f1e3194941d805b05..54b29d0ad764266212480140775e3f6355bfbff4 100644
--- a/pkgs/parallel.nix
+++ b/pkgs/parallel.nix
@@ -12,4 +12,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Parallel programming library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/pcg-random.nix b/pkgs/pcg-random.nix
index 8b36621c5e9a039962e3640d27d40097736d4147..33cde9a56b19c74d8c63f09fce99831ecb21a698 100644
--- a/pkgs/pcg-random.nix
+++ b/pkgs/pcg-random.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, base, bytestring, Cabal, cabal-doctest, doctest
-, entropy, lib, primitive, random
+{ mkDerivation
+, base
+, bytestring
+, Cabal
+, cabal-doctest
+, doctest
+, entropy
+, lib
+, primitive
+, random
 }:
 mkDerivation {
   pname = "pcg-random";
@@ -7,7 +15,11 @@ mkDerivation {
   sha256 = "e6c8c26841b5d0d6d9e2816e952e397062730fd1a0bc13cf7c3ebcba6dc1d2d0";
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
-    base bytestring entropy primitive random
+    base
+    bytestring
+    entropy
+    primitive
+    random
   ];
   testHaskellDepends = [ base doctest ];
   doHaddock = false;
@@ -17,4 +29,4 @@ mkDerivation {
   homepage = "http://github.com/cchalmers/pcg-random";
   description = "Haskell bindings to the PCG random number generator";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/polysemy-extra.nix b/pkgs/polysemy-extra.nix
index ccdfa3a4cc97ba15034967559afcc83b35f99778..5cd75a029e6cd529b7bff4f6e027e2c172ce850d 100644
--- a/pkgs/polysemy-extra.nix
+++ b/pkgs/polysemy-extra.nix
@@ -1,11 +1,19 @@
-{ mkDerivation, base, containers, lib, polysemy, polysemy-kvstore
+{ mkDerivation
+, base
+, containers
+, lib
+, polysemy
+, polysemy-kvstore
 }:
 mkDerivation {
   pname = "polysemy-extra";
   version = "0.2.1.0";
   sha256 = "523b9f267afbe492238e072fa39c1153e5fb471709d0c77802125a96494c5ec0";
   libraryHaskellDepends = [
-    base containers polysemy polysemy-kvstore
+    base
+    containers
+    polysemy
+    polysemy-kvstore
   ];
   doHaddock = false;
   jailbreak = true;
@@ -13,4 +21,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Extra Input and Output functions for polysemy";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/polysemy-kvstore.nix b/pkgs/polysemy-kvstore.nix
index 2ec396a1ba710b5b523913c7f073ed191c29c0f5..6d9a19506501950fac175a54c80f84ce8ded2ccb 100644
--- a/pkgs/polysemy-kvstore.nix
+++ b/pkgs/polysemy-kvstore.nix
@@ -10,4 +10,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "KVStore effect for polysemy";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/polysemy-methodology.nix b/pkgs/polysemy-methodology.nix
index 3583eabe1069f447c5a0cc5e20675887e7fed9b5..4d1679e2675904f29becacaaa54fe5a6b60a6aa1 100644
--- a/pkgs/polysemy-methodology.nix
+++ b/pkgs/polysemy-methodology.nix
@@ -1,4 +1,8 @@
-{ mkDerivation, base, lib, polysemy, polysemy-kvstore
+{ mkDerivation
+, base
+, lib
+, polysemy
+, polysemy-kvstore
 , polysemy-several
 }:
 mkDerivation {
@@ -8,7 +12,10 @@ mkDerivation {
   revision = "2";
   editedCabalFile = "0dpancn85f8j3pxhk43lik6fbznp502cc68rkhqkan791kh1bbc7";
   libraryHaskellDepends = [
-    base polysemy polysemy-kvstore polysemy-several
+    base
+    polysemy
+    polysemy-kvstore
+    polysemy-several
   ];
   doHaddock = false;
   jailbreak = true;
@@ -16,4 +23,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Domain modelling algebra for polysemy";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/polysemy-path.nix b/pkgs/polysemy-path.nix
index f52e0e763f24f1c5905a204f3ee781b24d380cca..3a478300a43f8dcb65efa6b4dc5a2cfee9571159 100644
--- a/pkgs/polysemy-path.nix
+++ b/pkgs/polysemy-path.nix
@@ -12,4 +12,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Polysemy versions of Path functions";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/polysemy-plugin.nix b/pkgs/polysemy-plugin.nix
index 0e68f525d00c36eb002c5bd3882184c444c1633c..cd26b0b8773d4aba6527263eb1256d53ce84cf3e 100644
--- a/pkgs/polysemy-plugin.nix
+++ b/pkgs/polysemy-plugin.nix
@@ -1,6 +1,19 @@
-{ mkDerivation, base, Cabal, cabal-doctest, containers, doctest
-, fetchgit, ghc, ghc-tcplugins-extra, hspec, hspec-discover
-, inspection-testing, lib, polysemy, should-not-typecheck, syb
+{ mkDerivation
+, base
+, Cabal
+, cabal-doctest
+, containers
+, doctest
+, fetchgit
+, ghc
+, ghc-tcplugins-extra
+, hspec
+, hspec-discover
+, inspection-testing
+, lib
+, polysemy
+, should-not-typecheck
+, syb
 , transformers
 }:
 mkDerivation {
@@ -15,11 +28,26 @@ mkDerivation {
   postUnpack = "sourceRoot+=/polysemy-plugin/; echo source root reset to $sourceRoot";
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
-    base containers ghc ghc-tcplugins-extra polysemy syb transformers
+    base
+    containers
+    ghc
+    ghc-tcplugins-extra
+    polysemy
+    syb
+    transformers
   ];
   testHaskellDepends = [
-    base containers doctest ghc ghc-tcplugins-extra hspec
-    inspection-testing polysemy should-not-typecheck syb transformers
+    base
+    containers
+    doctest
+    ghc
+    ghc-tcplugins-extra
+    hspec
+    inspection-testing
+    polysemy
+    should-not-typecheck
+    syb
+    transformers
   ];
   testToolDepends = [ hspec-discover ];
   doHaddock = false;
@@ -29,4 +57,4 @@ mkDerivation {
   homepage = "https://github.com/polysemy-research/polysemy#readme";
   description = "Disambiguate obvious uses of effects";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/polysemy-several.nix b/pkgs/polysemy-several.nix
index 7476b9037397b1f35708a09113f8c9ff8d4742bf..f2fbc4611bfecf6d34b4524fd5a01c6fa4d7f170 100644
--- a/pkgs/polysemy-several.nix
+++ b/pkgs/polysemy-several.nix
@@ -10,4 +10,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Run several effects at once, taken from the polysemy-zoo";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/polysemy-time.nix b/pkgs/polysemy-time.nix
index 6621850312a57394e79fb93753f87c4a784606e6..9abed2ca1a58045998de1abb5ec13a2d066376bc 100644
--- a/pkgs/polysemy-time.nix
+++ b/pkgs/polysemy-time.nix
@@ -1,15 +1,34 @@
-{ mkDerivation, aeson, base, incipit-core, lib, polysemy-test, stm
-, tasty, template-haskell, time, torsor
+{ mkDerivation
+, aeson
+, base
+, incipit-core
+, lib
+, polysemy-test
+, stm
+, tasty
+, template-haskell
+, time
+, torsor
 }:
 mkDerivation {
   pname = "polysemy-time";
   version = "0.5.1.0";
   sha256 = "857dbbe99e6e6a1a061aa9cac88a630f2bddc0c748ed8ec8d076b3b44d11e59a";
   libraryHaskellDepends = [
-    aeson base incipit-core stm template-haskell time torsor
+    aeson
+    base
+    incipit-core
+    stm
+    template-haskell
+    time
+    torsor
   ];
   testHaskellDepends = [
-    base incipit-core polysemy-test tasty time
+    base
+    incipit-core
+    polysemy-test
+    tasty
+    time
   ];
   doHaddock = false;
   jailbreak = true;
@@ -18,4 +37,4 @@ mkDerivation {
   homepage = "https://github.com/tek/polysemy-time#readme";
   description = "Polysemy effects for time";
   license = "BSD-2-Clause-Patent";
-}
\ No newline at end of file
+}
diff --git a/pkgs/polysemy-vinyl.nix b/pkgs/polysemy-vinyl.nix
index 659d550a207237bc056048ce4a7316f84676df5d..174c2a2eea683f4ec774bf53751fa15993b89cfe 100644
--- a/pkgs/polysemy-vinyl.nix
+++ b/pkgs/polysemy-vinyl.nix
@@ -1,5 +1,10 @@
-{ mkDerivation, base, lib, polysemy, polysemy-extra
-, polysemy-several, vinyl
+{ mkDerivation
+, base
+, lib
+, polysemy
+, polysemy-extra
+, polysemy-several
+, vinyl
 }:
 mkDerivation {
   pname = "polysemy-vinyl";
@@ -8,7 +13,11 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "13f289dxr03habyggn3vl7lzrl2r3a9r0y0bisrfmq48qaiv08n1";
   libraryHaskellDepends = [
-    base polysemy polysemy-extra polysemy-several vinyl
+    base
+    polysemy
+    polysemy-extra
+    polysemy-several
+    vinyl
   ];
   doHaddock = false;
   jailbreak = true;
@@ -16,4 +25,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Functions for mapping vinyl records in polysemy";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/polysemy-zoo.nix b/pkgs/polysemy-zoo.nix
index 33bbc4bc8b5570ea0491c8ca5beb6da5998e3bed..a4a07430774a443ce051e094f3500128394423aa 100644
--- a/pkgs/polysemy-zoo.nix
+++ b/pkgs/polysemy-zoo.nix
@@ -1,20 +1,63 @@
-{ mkDerivation, async, base, compact, constraints, containers
-, contravariant, exceptions, ghc-prim, hspec, hspec-discover, lib
-, mtl, polysemy, polysemy-plugin, random, reflection, streaming
-, text, transformers
+{ mkDerivation
+, async
+, base
+, compact
+, constraints
+, containers
+, contravariant
+, exceptions
+, ghc-prim
+, hspec
+, hspec-discover
+, lib
+, mtl
+, polysemy
+, polysemy-plugin
+, random
+, reflection
+, streaming
+, text
+, transformers
 }:
 mkDerivation {
   pname = "polysemy-zoo";
   version = "0.8.0.0";
   sha256 = "8c46937c61c980ac3024c4eeb1bf32a686eb2c5bcc2a65fad25d102512c89afa";
   libraryHaskellDepends = [
-    async base compact constraints containers contravariant exceptions
-    ghc-prim mtl polysemy random reflection streaming text transformers
+    async
+    base
+    compact
+    constraints
+    containers
+    contravariant
+    exceptions
+    ghc-prim
+    mtl
+    polysemy
+    random
+    reflection
+    streaming
+    text
+    transformers
   ];
   testHaskellDepends = [
-    async base compact constraints containers contravariant exceptions
-    ghc-prim hspec mtl polysemy polysemy-plugin random reflection
-    streaming text transformers
+    async
+    base
+    compact
+    constraints
+    containers
+    contravariant
+    exceptions
+    ghc-prim
+    hspec
+    mtl
+    polysemy
+    polysemy-plugin
+    random
+    reflection
+    streaming
+    text
+    transformers
   ];
   testToolDepends = [ hspec-discover ];
   doHaddock = false;
@@ -24,4 +67,4 @@ mkDerivation {
   homepage = "https://github.com/isovector/polysemy-zoo#readme";
   description = "Experimental, user-contributed effects and interpreters for polysemy";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/polysemy.nix b/pkgs/polysemy.nix
index e96692fc4929dc8e940eda5a949826d8bb34a6d6..bf7e3cc18dce677650fe8b1c7883d4ceb5cfc515 100644
--- a/pkgs/polysemy.nix
+++ b/pkgs/polysemy.nix
@@ -1,8 +1,27 @@
-{ mkDerivation, async, base, Cabal, cabal-doctest, containers
-, criterion, doctest, first-class-families, free, freer-simple
-, hspec, hspec-discover, inspection-testing, lib, mtl, QuickCheck
-, stm, syb, template-haskell, th-abstraction, transformers
-, type-errors, unagi-chan
+{ mkDerivation
+, async
+, base
+, Cabal
+, cabal-doctest
+, containers
+, criterion
+, doctest
+, first-class-families
+, free
+, freer-simple
+, hspec
+, hspec-discover
+, inspection-testing
+, lib
+, mtl
+, QuickCheck
+, stm
+, syb
+, template-haskell
+, th-abstraction
+, transformers
+, type-errors
+, unagi-chan
 }:
 mkDerivation {
   pname = "polysemy";
@@ -10,19 +29,56 @@ mkDerivation {
   sha256 = "4c9556c0c3f38f5fa655567106ecb53cd357e6ffaf8289753ba6dc26fd4bc224";
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
-    async base containers first-class-families mtl QuickCheck stm syb
-    template-haskell th-abstraction transformers type-errors unagi-chan
+    async
+    base
+    containers
+    first-class-families
+    mtl
+    QuickCheck
+    stm
+    syb
+    template-haskell
+    th-abstraction
+    transformers
+    type-errors
+    unagi-chan
   ];
   testHaskellDepends = [
-    async base containers doctest first-class-families hspec
-    inspection-testing mtl QuickCheck stm syb template-haskell
-    th-abstraction transformers type-errors unagi-chan
+    async
+    base
+    containers
+    doctest
+    first-class-families
+    hspec
+    inspection-testing
+    mtl
+    QuickCheck
+    stm
+    syb
+    template-haskell
+    th-abstraction
+    transformers
+    type-errors
+    unagi-chan
   ];
   testToolDepends = [ hspec-discover ];
   benchmarkHaskellDepends = [
-    async base containers criterion first-class-families free
-    freer-simple mtl QuickCheck stm syb template-haskell th-abstraction
-    transformers type-errors unagi-chan
+    async
+    base
+    containers
+    criterion
+    first-class-families
+    free
+    freer-simple
+    mtl
+    QuickCheck
+    stm
+    syb
+    template-haskell
+    th-abstraction
+    transformers
+    type-errors
+    unagi-chan
   ];
   doHaddock = false;
   jailbreak = true;
@@ -31,4 +87,4 @@ mkDerivation {
   homepage = "https://github.com/polysemy-research/polysemy#readme";
   description = "Higher-order, low-boilerplate free monads";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/postgresql-libpq.nix b/pkgs/postgresql-libpq.nix
index 0de659e1efd00c97f1b7ec76f450aa8e16ce3db9..7305d9c8be68a9b1d95240c6f245ec0e2a31eac2 100644
--- a/pkgs/postgresql-libpq.nix
+++ b/pkgs/postgresql-libpq.nix
@@ -16,4 +16,4 @@ mkDerivation {
   homepage = "https://github.com/haskellari/postgresql-libpq";
   description = "low-level binding to libpq";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/postgresql-simple.nix b/pkgs/postgresql-simple.nix
index 571ca79bed2fc5979108a9659f5a5d04afbdfa75..233b8084abd9df4ed15f71991b0fdf20c3c78a1d 100644
--- a/pkgs/postgresql-simple.nix
+++ b/pkgs/postgresql-simple.nix
@@ -1,9 +1,30 @@
-{ mkDerivation, aeson, attoparsec, base, base16-bytestring
-, bytestring, bytestring-builder, case-insensitive, containers
-, cryptohash-md5, filepath, hashable, HUnit, inspection-testing
-, lib, Only, postgresql-libpq, scientific, tasty, tasty-golden
-, tasty-hunit, template-haskell, text, time-compat, transformers
-, uuid-types, vector
+{ mkDerivation
+, aeson
+, attoparsec
+, base
+, base16-bytestring
+, bytestring
+, bytestring-builder
+, case-insensitive
+, containers
+, cryptohash-md5
+, filepath
+, hashable
+, HUnit
+, inspection-testing
+, lib
+, Only
+, postgresql-libpq
+, scientific
+, tasty
+, tasty-golden
+, tasty-hunit
+, template-haskell
+, text
+, time-compat
+, transformers
+, uuid-types
+, vector
 }:
 mkDerivation {
   pname = "postgresql-simple";
@@ -12,15 +33,42 @@ mkDerivation {
   revision = "8";
   editedCabalFile = "1qavb3qs1g307pc19k9y3yvqp0c1srwsplijvayn9ldp0bxdy6q8";
   libraryHaskellDepends = [
-    aeson attoparsec base bytestring bytestring-builder
-    case-insensitive containers hashable Only postgresql-libpq
-    scientific template-haskell text time-compat transformers
-    uuid-types vector
+    aeson
+    attoparsec
+    base
+    bytestring
+    bytestring-builder
+    case-insensitive
+    containers
+    hashable
+    Only
+    postgresql-libpq
+    scientific
+    template-haskell
+    text
+    time-compat
+    transformers
+    uuid-types
+    vector
   ];
   testHaskellDepends = [
-    aeson base base16-bytestring bytestring case-insensitive containers
-    cryptohash-md5 filepath HUnit inspection-testing postgresql-libpq
-    tasty tasty-golden tasty-hunit text time-compat vector
+    aeson
+    base
+    base16-bytestring
+    bytestring
+    case-insensitive
+    containers
+    cryptohash-md5
+    filepath
+    HUnit
+    inspection-testing
+    postgresql-libpq
+    tasty
+    tasty-golden
+    tasty-hunit
+    text
+    time-compat
+    vector
   ];
   benchmarkHaskellDepends = [ base vector ];
   doHaddock = false;
@@ -29,4 +77,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Mid-Level PostgreSQL client library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/pretty-simple.nix b/pkgs/pretty-simple.nix
index 410e2c15b3807b525f047c814ea8136e6bf01a96..7171590a522f42be8f55e39e4c102d15e4fe4388 100644
--- a/pkgs/pretty-simple.nix
+++ b/pkgs/pretty-simple.nix
@@ -1,6 +1,19 @@
-{ mkDerivation, base, Cabal, cabal-doctest, containers, criterion
-, doctest, Glob, lib, mtl, optparse-applicative, prettyprinter
-, prettyprinter-ansi-terminal, QuickCheck, template-haskell, text
+{ mkDerivation
+, base
+, Cabal
+, cabal-doctest
+, containers
+, criterion
+, doctest
+, Glob
+, lib
+, mtl
+, optparse-applicative
+, prettyprinter
+, prettyprinter-ansi-terminal
+, QuickCheck
+, template-haskell
+, text
 , transformers
 }:
 mkDerivation {
@@ -11,12 +24,21 @@ mkDerivation {
   isExecutable = true;
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
-    base containers mtl prettyprinter prettyprinter-ansi-terminal text
+    base
+    containers
+    mtl
+    prettyprinter
+    prettyprinter-ansi-terminal
+    text
     transformers
   ];
   executableHaskellDepends = [ base optparse-applicative text ];
   testHaskellDepends = [
-    base doctest Glob QuickCheck template-haskell
+    base
+    doctest
+    Glob
+    QuickCheck
+    template-haskell
   ];
   benchmarkHaskellDepends = [ base criterion text ];
   doHaddock = false;
@@ -27,4 +49,4 @@ mkDerivation {
   description = "pretty printer for data types with a 'Show' instance";
   license = lib.licenses.bsd3;
   mainProgram = "pretty-simple";
-}
\ No newline at end of file
+}
diff --git a/pkgs/prettyprinter-ansi-terminal.nix b/pkgs/prettyprinter-ansi-terminal.nix
index ab74c0e88fac85f09210182c0346cc1c387add3d..bfb45f1f5bdb3b838f8159c0d684590445f3b375 100644
--- a/pkgs/prettyprinter-ansi-terminal.nix
+++ b/pkgs/prettyprinter-ansi-terminal.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, ansi-terminal, base, base-compat, containers
-, deepseq, doctest, gauge, lib, prettyprinter, QuickCheck, text
+{ mkDerivation
+, ansi-terminal
+, base
+, base-compat
+, containers
+, deepseq
+, doctest
+, gauge
+, lib
+, prettyprinter
+, QuickCheck
+, text
 }:
 mkDerivation {
   pname = "prettyprinter-ansi-terminal";
@@ -8,7 +18,13 @@ mkDerivation {
   libraryHaskellDepends = [ ansi-terminal base prettyprinter text ];
   testHaskellDepends = [ base doctest ];
   benchmarkHaskellDepends = [
-    base base-compat containers deepseq gauge prettyprinter QuickCheck
+    base
+    base-compat
+    containers
+    deepseq
+    gauge
+    prettyprinter
+    QuickCheck
     text
   ];
   doHaddock = false;
@@ -18,4 +34,4 @@ mkDerivation {
   homepage = "http://github.com/quchen/prettyprinter";
   description = "ANSI terminal backend for the »prettyprinter« package";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+}
diff --git a/pkgs/primitive.nix b/pkgs/primitive.nix
index e15176e82e03c5b7f1b32be7ec3a60af09b47fc5..ad2442fd2a49e5d52126789c759c6f975910fff8 100644
--- a/pkgs/primitive.nix
+++ b/pkgs/primitive.nix
@@ -1,6 +1,17 @@
-{ mkDerivation, base, base-orphans, deepseq, ghc-prim, lib
-, QuickCheck, quickcheck-classes-base, tagged, tasty, tasty-bench
-, tasty-quickcheck, template-haskell, transformers
+{ mkDerivation
+, base
+, base-orphans
+, deepseq
+, ghc-prim
+, lib
+, QuickCheck
+, quickcheck-classes-base
+, tagged
+, tasty
+, tasty-bench
+, tasty-quickcheck
+, template-haskell
+, transformers
 , transformers-compat
 }:
 mkDerivation {
@@ -8,14 +19,28 @@ mkDerivation {
   version = "0.7.4.0";
   sha256 = "5b2d6dc2812eb2f6a115f05fcbe3e723d3aeff7894b012c617e075130581add5";
   libraryHaskellDepends = [
-    base deepseq template-haskell transformers
+    base
+    deepseq
+    template-haskell
+    transformers
   ];
   testHaskellDepends = [
-    base base-orphans ghc-prim QuickCheck quickcheck-classes-base
-    tagged tasty tasty-quickcheck transformers transformers-compat
+    base
+    base-orphans
+    ghc-prim
+    QuickCheck
+    quickcheck-classes-base
+    tagged
+    tasty
+    tasty-quickcheck
+    transformers
+    transformers-compat
   ];
   benchmarkHaskellDepends = [
-    base deepseq tasty-bench transformers
+    base
+    deepseq
+    tasty-bench
+    transformers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -24,4 +49,4 @@ mkDerivation {
   homepage = "https://github.com/haskell/primitive";
   description = "Primitive memory-related operations";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/proteaaudio-sdl.nix b/pkgs/proteaaudio-sdl.nix
index 18fe6c85ae1ea6b7967266c54e1b90561095cc55..c4e02db3400000d42792b1a7f1fa73b92beb61b6 100644
--- a/pkgs/proteaaudio-sdl.nix
+++ b/pkgs/proteaaudio-sdl.nix
@@ -15,4 +15,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Simple audio library for SDL";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/quickcheck-dynamic.nix b/pkgs/quickcheck-dynamic.nix
index afe6f8c31666516034872a673e190d5c56da2bfa..f6d2839ab7cde6d29b76e8e89a6cc754a96cc265 100644
--- a/pkgs/quickcheck-dynamic.nix
+++ b/pkgs/quickcheck-dynamic.nix
@@ -11,4 +11,4 @@ mkDerivation {
   homepage = "https://github.com/input-output-hk/quickcheck-dynamic#readme";
   description = "A library for stateful property-based testing";
   license = lib.licenses.asl20;
-}
\ No newline at end of file
+}
diff --git a/pkgs/quickcheck-instances.nix b/pkgs/quickcheck-instances.nix
index 93ec8c7312e880f8a4bced74ef3e67e632540a4d..a4a0986d594c063676242854e625dadd2f45a686 100644
--- a/pkgs/quickcheck-instances.nix
+++ b/pkgs/quickcheck-instances.nix
@@ -1,22 +1,71 @@
-{ mkDerivation, array, base, bytestring, case-insensitive
-, containers, data-fix, hashable, integer-logarithms, lib, old-time
-, OneTuple, primitive, QuickCheck, scientific, splitmix, strict
-, tagged, text, text-short, these, time, time-compat, transformers
-, transformers-compat, unordered-containers, uuid-types, vector
+{ mkDerivation
+, array
+, base
+, bytestring
+, case-insensitive
+, containers
+, data-fix
+, hashable
+, integer-logarithms
+, lib
+, old-time
+, OneTuple
+, primitive
+, QuickCheck
+, scientific
+, splitmix
+, strict
+, tagged
+, text
+, text-short
+, these
+, time
+, time-compat
+, transformers
+, transformers-compat
+, unordered-containers
+, uuid-types
+, vector
 }:
 mkDerivation {
   pname = "quickcheck-instances";
   version = "0.3.28";
   sha256 = "c4111b7b49d5814120cb6055705d04eda7dd32a536057167c646aa77b68ccccb";
   libraryHaskellDepends = [
-    array base bytestring case-insensitive containers data-fix hashable
-    integer-logarithms old-time OneTuple primitive QuickCheck
-    scientific splitmix strict tagged text text-short these time
-    time-compat transformers transformers-compat unordered-containers
-    uuid-types vector
+    array
+    base
+    bytestring
+    case-insensitive
+    containers
+    data-fix
+    hashable
+    integer-logarithms
+    old-time
+    OneTuple
+    primitive
+    QuickCheck
+    scientific
+    splitmix
+    strict
+    tagged
+    text
+    text-short
+    these
+    time
+    time-compat
+    transformers
+    transformers-compat
+    unordered-containers
+    uuid-types
+    vector
   ];
   testHaskellDepends = [
-    base containers primitive QuickCheck tagged uuid-types
+    base
+    containers
+    primitive
+    QuickCheck
+    tagged
+    uuid-types
   ];
   benchmarkHaskellDepends = [ base bytestring QuickCheck ];
   doHaddock = false;
@@ -26,4 +75,4 @@ mkDerivation {
   homepage = "https://github.com/haskellari/qc-instances";
   description = "Common quickcheck instances";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/rebase.nix b/pkgs/rebase.nix
index 951638015b4d6241333006672aa519b30fd5856f..f976214cfb614b543ab1863c8a89636650343795 100644
--- a/pkgs/rebase.nix
+++ b/pkgs/rebase.nix
@@ -1,8 +1,32 @@
-{ mkDerivation, base, bifunctors, bytestring, comonad, containers
-, contravariant, deepseq, dlist, either, groups, hashable
-, invariant, lib, mtl, profunctors, scientific, selective
-, semigroupoids, stm, text, time, time-compat, transformers
-, unordered-containers, uuid-types, vector, vector-instances, void
+{ mkDerivation
+, base
+, bifunctors
+, bytestring
+, comonad
+, containers
+, contravariant
+, deepseq
+, dlist
+, either
+, groups
+, hashable
+, invariant
+, lib
+, mtl
+, profunctors
+, scientific
+, selective
+, semigroupoids
+, stm
+, text
+, time
+, time-compat
+, transformers
+, unordered-containers
+, uuid-types
+, vector
+, vector-instances
+, void
 }:
 mkDerivation {
   pname = "rebase";
@@ -11,10 +35,33 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "048h2ir37j09s0z7fb364p7smyhzq6h4705qklhvylak9242gz2n";
   libraryHaskellDepends = [
-    base bifunctors bytestring comonad containers contravariant deepseq
-    dlist either groups hashable invariant mtl profunctors scientific
-    selective semigroupoids stm text time time-compat transformers
-    unordered-containers uuid-types vector vector-instances void
+    base
+    bifunctors
+    bytestring
+    comonad
+    containers
+    contravariant
+    deepseq
+    dlist
+    either
+    groups
+    hashable
+    invariant
+    mtl
+    profunctors
+    scientific
+    selective
+    semigroupoids
+    stm
+    text
+    time
+    time-compat
+    transformers
+    unordered-containers
+    uuid-types
+    vector
+    vector-instances
+    void
   ];
   doHaddock = false;
   jailbreak = true;
@@ -23,4 +70,4 @@ mkDerivation {
   homepage = "https://github.com/nikita-volkov/rebase";
   description = "A more progressive alternative to the \"base\" package";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/relude.nix b/pkgs/relude.nix
index 520c0115ee3c2d906933f15338921c57dc7cadfe..52504119925a73ee80556abf02b5b524679a3533 100644
--- a/pkgs/relude.nix
+++ b/pkgs/relude.nix
@@ -1,20 +1,51 @@
-{ mkDerivation, base, bytestring, containers, deepseq, doctest
-, ghc-prim, Glob, hashable, hedgehog, lib, mtl, stm, tasty-bench
-, text, transformers, unordered-containers
+{ mkDerivation
+, base
+, bytestring
+, containers
+, deepseq
+, doctest
+, ghc-prim
+, Glob
+, hashable
+, hedgehog
+, lib
+, mtl
+, stm
+, tasty-bench
+, text
+, transformers
+, unordered-containers
 }:
 mkDerivation {
   pname = "relude";
   version = "1.1.0.0";
   sha256 = "b51df08a93ef1331dd56389e158e67ac7b68c62cc1561c2890d3572c764ab609";
   libraryHaskellDepends = [
-    base bytestring containers deepseq ghc-prim hashable mtl stm text
-    transformers unordered-containers
+    base
+    bytestring
+    containers
+    deepseq
+    ghc-prim
+    hashable
+    mtl
+    stm
+    text
+    transformers
+    unordered-containers
   ];
   testHaskellDepends = [
-    base bytestring containers doctest Glob hedgehog text
+    base
+    bytestring
+    containers
+    doctest
+    Glob
+    hedgehog
+    text
   ];
   benchmarkHaskellDepends = [
-    base tasty-bench unordered-containers
+    base
+    tasty-bench
+    unordered-containers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -23,4 +54,4 @@ mkDerivation {
   homepage = "https://github.com/kowainik/relude";
   description = "Safe, performant, user-friendly and lightweight Haskell Standard Library";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/rerebase.nix b/pkgs/rerebase.nix
index 3ad251f3611eb59fcffef0c1e31cf813fc7519c7..7b64c9ac198f63e30c1faded45959c7c22cc7bc8 100644
--- a/pkgs/rerebase.nix
+++ b/pkgs/rerebase.nix
@@ -11,4 +11,4 @@ mkDerivation {
   homepage = "https://github.com/nikita-volkov/rerebase";
   description = "Reexports from \"base\" with a bunch of other standard libraries";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/retry.nix b/pkgs/retry.nix
index af7dd6141862b59a077731d9158fa3e641f30a47..3c2cde7035edec5ecb68c926498d062be21eb38b 100644
--- a/pkgs/retry.nix
+++ b/pkgs/retry.nix
@@ -1,18 +1,51 @@
-{ mkDerivation, base, exceptions, ghc-prim, hedgehog, HUnit, lib
-, mtl, mtl-compat, random, stm, tasty, tasty-hedgehog, tasty-hunit
-, time, transformers, unliftio-core
+{ mkDerivation
+, base
+, exceptions
+, ghc-prim
+, hedgehog
+, HUnit
+, lib
+, mtl
+, mtl-compat
+, random
+, stm
+, tasty
+, tasty-hedgehog
+, tasty-hunit
+, time
+, transformers
+, unliftio-core
 }:
 mkDerivation {
   pname = "retry";
   version = "0.9.3.0";
   sha256 = "c11e5dcb6fc9b7a327ebdf9188edcbe39fce64e728294e41a61e9ad94fa84ecd";
   libraryHaskellDepends = [
-    base exceptions ghc-prim mtl mtl-compat random transformers
+    base
+    exceptions
+    ghc-prim
+    mtl
+    mtl-compat
+    random
+    transformers
     unliftio-core
   ];
   testHaskellDepends = [
-    base exceptions ghc-prim hedgehog HUnit mtl mtl-compat random stm
-    tasty tasty-hedgehog tasty-hunit time transformers unliftio-core
+    base
+    exceptions
+    ghc-prim
+    hedgehog
+    HUnit
+    mtl
+    mtl-compat
+    random
+    stm
+    tasty
+    tasty-hedgehog
+    tasty-hunit
+    time
+    transformers
+    unliftio-core
   ];
   doHaddock = false;
   jailbreak = true;
@@ -21,4 +54,4 @@ mkDerivation {
   homepage = "http://github.com/Soostone/retry";
   description = "Retry combinators for monadic actions that may fail";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/rope-utf16-splay.nix b/pkgs/rope-utf16-splay.nix
index 09e6140d4ca358567d4c394b5e89250406ee6c98..b08f639666805b9cd30e02a588c3830ab7bb2526 100644
--- a/pkgs/rope-utf16-splay.nix
+++ b/pkgs/rope-utf16-splay.nix
@@ -1,5 +1,11 @@
-{ mkDerivation, base, lib, QuickCheck, tasty, tasty-hunit
-, tasty-quickcheck, text
+{ mkDerivation
+, base
+, lib
+, QuickCheck
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, text
 }:
 mkDerivation {
   pname = "rope-utf16-splay";
@@ -7,7 +13,12 @@ mkDerivation {
   sha256 = "c189f1ccac3a2bf92dd2b7f85b194364983813d350870011ac71165f5b2f5fee";
   libraryHaskellDepends = [ base text ];
   testHaskellDepends = [
-    base QuickCheck tasty tasty-hunit tasty-quickcheck text
+    base
+    QuickCheck
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -16,4 +27,4 @@ mkDerivation {
   homepage = "https://github.com/ollef/rope-utf16-splay";
   description = "Ropes optimised for updating using UTF-16 code units and row/column pairs";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/safe-coloured-text.nix b/pkgs/safe-coloured-text.nix
index cdcaaa94e91975056e1b72c0535d29045623bebb..39b372807d16b6984f5be4c47e98643dd17ecf13 100644
--- a/pkgs/safe-coloured-text.nix
+++ b/pkgs/safe-coloured-text.nix
@@ -1,12 +1,23 @@
-{ mkDerivation, base, bytestring, lib, text, validity
-, validity-bytestring, validity-text
+{ mkDerivation
+, base
+, bytestring
+, lib
+, text
+, validity
+, validity-bytestring
+, validity-text
 }:
 mkDerivation {
   pname = "safe-coloured-text";
   version = "0.2.0.1";
   sha256 = "b1604a221ee28e672a5b876a9f368ebbd65d56cc93afeb486083857d7c9b1759";
   libraryHaskellDepends = [
-    base bytestring text validity validity-bytestring validity-text
+    base
+    bytestring
+    text
+    validity
+    validity-bytestring
+    validity-text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -15,4 +26,4 @@ mkDerivation {
   homepage = "https://github.com/NorfairKing/safe-coloured-text#readme";
   description = "Safely output coloured text";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/saltine.nix b/pkgs/saltine.nix
index 3bf53e443e5df03cd296ded246090bc918084dec..e74e19a31d903f80069eb99e628e1f2be838701d 100644
--- a/pkgs/saltine.nix
+++ b/pkgs/saltine.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, base, bytestring, hashable, lib, libsodium
-, profunctors, QuickCheck, semigroups, test-framework
+{ mkDerivation
+, base
+, bytestring
+, hashable
+, lib
+, libsodium
+, profunctors
+, QuickCheck
+, semigroups
+, test-framework
 , test-framework-quickcheck2
 }:
 mkDerivation {
@@ -9,7 +17,11 @@ mkDerivation {
   libraryHaskellDepends = [ base bytestring hashable profunctors ];
   libraryPkgconfigDepends = [ libsodium ];
   testHaskellDepends = [
-    base bytestring QuickCheck semigroups test-framework
+    base
+    bytestring
+    QuickCheck
+    semigroups
+    test-framework
     test-framework-quickcheck2
   ];
   doHaddock = false;
@@ -18,4 +30,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Cryptography that's easy to digest (NaCl/libsodium bindings)";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/scientific.nix b/pkgs/scientific.nix
index 3b59e0e70fb5ed11e38ccce9184a1d10878394d4..9e85fbde6c2638c42be1374e0d1240fecccf4e39 100644
--- a/pkgs/scientific.nix
+++ b/pkgs/scientific.nix
@@ -1,7 +1,22 @@
-{ mkDerivation, base, binary, bytestring, containers, criterion
-, deepseq, hashable, integer-logarithms, lib, primitive, QuickCheck
-, smallcheck, tasty, tasty-hunit, tasty-quickcheck
-, tasty-smallcheck, template-haskell, text
+{ mkDerivation
+, base
+, binary
+, bytestring
+, containers
+, criterion
+, deepseq
+, hashable
+, integer-logarithms
+, lib
+, primitive
+, QuickCheck
+, smallcheck
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, tasty-smallcheck
+, template-haskell
+, text
 }:
 mkDerivation {
   pname = "scientific";
@@ -10,12 +25,28 @@ mkDerivation {
   revision = "3";
   editedCabalFile = "1n67w1b64q59nn4845z3kr8rm0x0p7bi3cyp6n1dpnfs8k4l8x2i";
   libraryHaskellDepends = [
-    base binary bytestring containers deepseq hashable
-    integer-logarithms primitive template-haskell text
+    base
+    binary
+    bytestring
+    containers
+    deepseq
+    hashable
+    integer-logarithms
+    primitive
+    template-haskell
+    text
   ];
   testHaskellDepends = [
-    base binary bytestring QuickCheck smallcheck tasty tasty-hunit
-    tasty-quickcheck tasty-smallcheck text
+    base
+    binary
+    bytestring
+    QuickCheck
+    smallcheck
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    tasty-smallcheck
+    text
   ];
   benchmarkHaskellDepends = [ base criterion ];
   doHaddock = false;
@@ -25,4 +56,4 @@ mkDerivation {
   homepage = "https://github.com/basvandijk/scientific";
   description = "Numbers represented using scientific notation";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/scotty.nix b/pkgs/scotty.nix
index 3fabb46849818d773c152e7df3726147013329a6..e71c7f9327c266b13814c07384d280d6f3dbe6be 100644
--- a/pkgs/scotty.nix
+++ b/pkgs/scotty.nix
@@ -1,9 +1,35 @@
-{ mkDerivation, aeson, async, base, base-compat-batteries
-, blaze-builder, bytestring, case-insensitive, data-default-class
-, directory, exceptions, fail, hspec, hspec-discover, hspec-wai
-, http-types, lib, lifted-base, lucid, monad-control, mtl, nats
-, network, regex-compat, text, transformers, transformers-base
-, transformers-compat, wai, wai-extra, warp, weigh
+{ mkDerivation
+, aeson
+, async
+, base
+, base-compat-batteries
+, blaze-builder
+, bytestring
+, case-insensitive
+, data-default-class
+, directory
+, exceptions
+, fail
+, hspec
+, hspec-discover
+, hspec-wai
+, http-types
+, lib
+, lifted-base
+, lucid
+, monad-control
+, mtl
+, nats
+, network
+, regex-compat
+, text
+, transformers
+, transformers-base
+, transformers-compat
+, wai
+, wai-extra
+, warp
+, weigh
 }:
 mkDerivation {
   pname = "scotty";
@@ -12,18 +38,52 @@ mkDerivation {
   revision = "9";
   editedCabalFile = "0d61dgx6wq682mz8ryq2a10v1z4yi0dik8b5psi0ragl2qip191j";
   libraryHaskellDepends = [
-    aeson base base-compat-batteries blaze-builder bytestring
-    case-insensitive data-default-class exceptions fail http-types
-    monad-control mtl nats network regex-compat text transformers
-    transformers-base transformers-compat wai wai-extra warp
+    aeson
+    base
+    base-compat-batteries
+    blaze-builder
+    bytestring
+    case-insensitive
+    data-default-class
+    exceptions
+    fail
+    http-types
+    monad-control
+    mtl
+    nats
+    network
+    regex-compat
+    text
+    transformers
+    transformers-base
+    transformers-compat
+    wai
+    wai-extra
+    warp
   ];
   testHaskellDepends = [
-    async base bytestring data-default-class directory hspec hspec-wai
-    http-types lifted-base network text wai
+    async
+    base
+    bytestring
+    data-default-class
+    directory
+    hspec
+    hspec-wai
+    http-types
+    lifted-base
+    network
+    text
+    wai
   ];
   testToolDepends = [ hspec-discover ];
   benchmarkHaskellDepends = [
-    base bytestring data-default-class lucid mtl text transformers
+    base
+    bytestring
+    data-default-class
+    lucid
+    mtl
+    text
+    transformers
     weigh
   ];
   doHaddock = false;
@@ -33,4 +93,4 @@ mkDerivation {
   homepage = "https://github.com/scotty-web/scotty";
   description = "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/sdl2-gfx.nix b/pkgs/sdl2-gfx.nix
index 07ff1295ffd3c73f0088e99895e2cb6007eb2e08..a090bd4424e70f41b691d7b27e963c284c27331c 100644
--- a/pkgs/sdl2-gfx.nix
+++ b/pkgs/sdl2-gfx.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, base, lib, lifted-base, monad-control, SDL2, sdl2
-, SDL2_gfx, template-haskell, vector
+{ mkDerivation
+, base
+, lib
+, lifted-base
+, monad-control
+, SDL2
+, sdl2
+, SDL2_gfx
+, template-haskell
+, vector
 }:
 mkDerivation {
   pname = "sdl2-gfx";
@@ -8,7 +16,12 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base lifted-base monad-control sdl2 template-haskell vector
+    base
+    lifted-base
+    monad-control
+    sdl2
+    template-haskell
+    vector
   ];
   librarySystemDepends = [ SDL2_gfx ];
   libraryPkgconfigDepends = [ SDL2 SDL2_gfx ];
@@ -22,4 +35,4 @@ mkDerivation {
   description = "Haskell bindings to SDL2_gfx";
   license = lib.licenses.mit;
   mainProgram = "sdl2-gfx-example";
-}
\ No newline at end of file
+}
diff --git a/pkgs/sdl2-image.nix b/pkgs/sdl2-image.nix
index 48416abe4e3b1327329df9e2adcdc497587cf5ca..d976ed46e5c188247e72d034ec4a8cbb521d6504 100644
--- a/pkgs/sdl2-image.nix
+++ b/pkgs/sdl2-image.nix
@@ -1,5 +1,12 @@
-{ mkDerivation, base, bytestring, lib, SDL2, sdl2, SDL2_image
-, template-haskell, text
+{ mkDerivation
+, base
+, bytestring
+, lib
+, SDL2
+, sdl2
+, SDL2_image
+, template-haskell
+, text
 }:
 mkDerivation {
   pname = "sdl2-image";
@@ -8,7 +15,11 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base bytestring sdl2 template-haskell text
+    base
+    bytestring
+    sdl2
+    template-haskell
+    text
   ];
   librarySystemDepends = [ SDL2_image ];
   libraryPkgconfigDepends = [ SDL2 SDL2_image ];
@@ -22,4 +33,4 @@ mkDerivation {
   description = "Haskell bindings to SDL2_image";
   license = lib.licenses.mit;
   mainProgram = "sdl2-image-example";
-}
\ No newline at end of file
+}
diff --git a/pkgs/sdl2-mixer.nix b/pkgs/sdl2-mixer.nix
index 350d1560163369c43cef2ec707fc470fb323e8c9..21f6272951982509b3eb30591216609198f2ca50 100644
--- a/pkgs/sdl2-mixer.nix
+++ b/pkgs/sdl2-mixer.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, base, bytestring, data-default-class, lib
-, lifted-base, monad-control, sdl2, SDL2_mixer, template-haskell
+{ mkDerivation
+, base
+, bytestring
+, data-default-class
+, lib
+, lifted-base
+, monad-control
+, sdl2
+, SDL2_mixer
+, template-haskell
 , vector
 }:
 mkDerivation {
@@ -9,8 +17,14 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base bytestring data-default-class lifted-base monad-control sdl2
-    template-haskell vector
+    base
+    bytestring
+    data-default-class
+    lifted-base
+    monad-control
+    sdl2
+    template-haskell
+    vector
   ];
   librarySystemDepends = [ SDL2_mixer ];
   libraryPkgconfigDepends = [ SDL2_mixer ];
@@ -23,4 +37,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Haskell bindings to SDL2_mixer";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/sdl2-ttf.nix b/pkgs/sdl2-ttf.nix
index cd486b75eb7366f86fd0c66b4a118262ee832958..b1e94b9789da32be9ff12f153439b5c3eba6bc82 100644
--- a/pkgs/sdl2-ttf.nix
+++ b/pkgs/sdl2-ttf.nix
@@ -1,5 +1,14 @@
-{ mkDerivation, base, bytestring, lib, SDL2, sdl2, SDL2_ttf
-, template-haskell, text, th-abstraction, transformers
+{ mkDerivation
+, base
+, bytestring
+, lib
+, SDL2
+, sdl2
+, SDL2_ttf
+, template-haskell
+, text
+, th-abstraction
+, transformers
 }:
 mkDerivation {
   pname = "sdl2-ttf";
@@ -8,7 +17,12 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base bytestring sdl2 template-haskell text th-abstraction
+    base
+    bytestring
+    sdl2
+    template-haskell
+    text
+    th-abstraction
     transformers
   ];
   libraryPkgconfigDepends = [ SDL2 SDL2_ttf ];
@@ -18,4 +32,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Bindings to SDL2_ttf";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/sdl2.nix b/pkgs/sdl2.nix
index f6caaa83dd7f2c7707ab2cdaab2499648af23e52..74d2f5938d91cd555e5dee5d021c5cd5b201655e 100644
--- a/pkgs/sdl2.nix
+++ b/pkgs/sdl2.nix
@@ -1,5 +1,16 @@
-{ mkDerivation, base, bytestring, deepseq, exceptions, lib, linear
-, SDL2, StateVar, text, transformers, vector, weigh
+{ mkDerivation
+, base
+, bytestring
+, deepseq
+, exceptions
+, lib
+, linear
+, SDL2
+, StateVar
+, text
+, transformers
+, vector
+, weigh
 }:
 mkDerivation {
   pname = "sdl2";
@@ -9,7 +20,14 @@ mkDerivation {
   isExecutable = true;
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
-    base bytestring exceptions linear StateVar text transformers vector
+    base
+    bytestring
+    exceptions
+    linear
+    StateVar
+    text
+    transformers
+    vector
   ];
   librarySystemDepends = [ SDL2 ];
   libraryPkgconfigDepends = [ SDL2 ];
@@ -20,4 +38,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Both high- and low-level bindings to the SDL library (version 2.0.6+).";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/semialign.nix b/pkgs/semialign.nix
index 83d748d1bb5a3b819c8e69505bda77ab2222c762..350a4f53b3c0e68f6eb1dffea96fa9d18a32ab5f 100644
--- a/pkgs/semialign.nix
+++ b/pkgs/semialign.nix
@@ -1,6 +1,16 @@
-{ mkDerivation, base, containers, hashable, indexed-traversable
-, indexed-traversable-instances, lib, semigroupoids, tagged, these
-, transformers, unordered-containers, vector
+{ mkDerivation
+, base
+, containers
+, hashable
+, indexed-traversable
+, indexed-traversable-instances
+, lib
+, semigroupoids
+, tagged
+, these
+, transformers
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "semialign";
@@ -9,9 +19,17 @@ mkDerivation {
   revision = "3";
   editedCabalFile = "0dbcdnksik508i12arh3s6bis6779lx5f1df0jkc0bp797inhd7f";
   libraryHaskellDepends = [
-    base containers hashable indexed-traversable
-    indexed-traversable-instances semigroupoids tagged these
-    transformers unordered-containers vector
+    base
+    containers
+    hashable
+    indexed-traversable
+    indexed-traversable-instances
+    semigroupoids
+    tagged
+    these
+    transformers
+    unordered-containers
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -20,4 +38,4 @@ mkDerivation {
   homepage = "https://github.com/haskellari/these";
   description = "Align and Zip type-classes from the common Semialign ancestor";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/serialise.nix b/pkgs/serialise.nix
index 4020fde46f6aa11be5eb04e0648b59457e201a90..33844d32798a459fa1c0b90b424fb2831bfb810c 100644
--- a/pkgs/serialise.nix
+++ b/pkgs/serialise.nix
@@ -1,27 +1,104 @@
-{ mkDerivation, aeson, array, base, binary, bytestring, cborg
-, cereal, cereal-vector, containers, criterion, deepseq, directory
-, fail, filepath, ghc-prim, half, hashable, lib, pretty, primitive
-, QuickCheck, quickcheck-instances, semigroups, store, strict, tar
-, tasty, tasty-hunit, tasty-quickcheck, text, these, time
-, unordered-containers, vector, zlib
+{ mkDerivation
+, aeson
+, array
+, base
+, binary
+, bytestring
+, cborg
+, cereal
+, cereal-vector
+, containers
+, criterion
+, deepseq
+, directory
+, fail
+, filepath
+, ghc-prim
+, half
+, hashable
+, lib
+, pretty
+, primitive
+, QuickCheck
+, quickcheck-instances
+, semigroups
+, store
+, strict
+, tar
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, text
+, these
+, time
+, unordered-containers
+, vector
+, zlib
 }:
 mkDerivation {
   pname = "serialise";
   version = "0.2.6.0";
   sha256 = "93ff1888e1972999f14663072b38efcfd0c1481b4ec8e30ddc9c5ce97681a516";
   libraryHaskellDepends = [
-    array base bytestring cborg containers ghc-prim half hashable
-    primitive strict text these time unordered-containers vector
+    array
+    base
+    bytestring
+    cborg
+    containers
+    ghc-prim
+    half
+    hashable
+    primitive
+    strict
+    text
+    these
+    time
+    unordered-containers
+    vector
   ];
   testHaskellDepends = [
-    base bytestring cborg containers directory filepath primitive
-    QuickCheck quickcheck-instances tasty tasty-hunit tasty-quickcheck
-    text time unordered-containers vector
+    base
+    bytestring
+    cborg
+    containers
+    directory
+    filepath
+    primitive
+    QuickCheck
+    quickcheck-instances
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    text
+    time
+    unordered-containers
+    vector
   ];
   benchmarkHaskellDepends = [
-    aeson array base binary bytestring cborg cereal cereal-vector
-    containers criterion deepseq directory fail filepath ghc-prim half
-    pretty semigroups store tar text time vector zlib
+    aeson
+    array
+    base
+    binary
+    bytestring
+    cborg
+    cereal
+    cereal-vector
+    containers
+    criterion
+    deepseq
+    directory
+    fail
+    filepath
+    ghc-prim
+    half
+    pretty
+    semigroups
+    store
+    tar
+    text
+    time
+    vector
+    zlib
   ];
   doHaddock = false;
   jailbreak = true;
@@ -30,4 +107,4 @@ mkDerivation {
   homepage = "https://github.com/well-typed/cborg";
   description = "A binary serialisation library for Haskell values";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/servant-client-core.nix b/pkgs/servant-client-core.nix
index ab71ec13b47c42bd3b96a5cc393dd5c4127fce9f..a5ca50c3fd800ab813deac9a202827021c5dc11c 100644
--- a/pkgs/servant-client-core.nix
+++ b/pkgs/servant-client-core.nix
@@ -1,8 +1,28 @@
-{ mkDerivation, aeson, base, base-compat, base64-bytestring
-, bytestring, constraints, containers, deepseq, exceptions
-, fetchgit, free, hspec, hspec-discover, http-media, http-types
-, lib, network-uri, QuickCheck, safe, servant, sop-core
-, template-haskell, text, transformers
+{ mkDerivation
+, aeson
+, base
+, base-compat
+, base64-bytestring
+, bytestring
+, constraints
+, containers
+, deepseq
+, exceptions
+, fetchgit
+, free
+, hspec
+, hspec-discover
+, http-media
+, http-types
+, lib
+, network-uri
+, QuickCheck
+, safe
+, servant
+, sop-core
+, template-haskell
+, text
+, transformers
 }:
 mkDerivation {
   pname = "servant-client-core";
@@ -15,9 +35,24 @@ mkDerivation {
   };
   postUnpack = "sourceRoot+=/servant-client-core/; echo source root reset to $sourceRoot";
   libraryHaskellDepends = [
-    aeson base base-compat base64-bytestring bytestring constraints
-    containers deepseq exceptions free http-media http-types
-    network-uri safe servant sop-core template-haskell text
+    aeson
+    base
+    base-compat
+    base64-bytestring
+    bytestring
+    constraints
+    containers
+    deepseq
+    exceptions
+    free
+    http-media
+    http-types
+    network-uri
+    safe
+    servant
+    sop-core
+    template-haskell
+    text
     transformers
   ];
   testHaskellDepends = [ base base-compat deepseq hspec QuickCheck ];
@@ -29,4 +64,4 @@ mkDerivation {
   homepage = "http://docs.servant.dev/";
   description = "Core functionality and class for client function generation for servant APIs";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/servant-client.nix b/pkgs/servant-client.nix
index 7359ce925e1432bfd9b7e12bc2a8fd184c932d80..7535d1ab52418aa41489a29eee9300dd2d1f7acb 100644
--- a/pkgs/servant-client.nix
+++ b/pkgs/servant-client.nix
@@ -1,10 +1,41 @@
-{ mkDerivation, aeson, base, base-compat, bytestring, containers
-, deepseq, entropy, exceptions, fetchgit, hspec, hspec-discover
-, http-api-data, http-client, http-media, http-types, HUnit
-, kan-extensions, lib, markdown-unlit, monad-control, mtl, network
-, QuickCheck, semigroupoids, servant, servant-client-core
-, servant-server, sop-core, stm, tdigest, text, time, transformers
-, transformers-base, transformers-compat, wai, warp
+{ mkDerivation
+, aeson
+, base
+, base-compat
+, bytestring
+, containers
+, deepseq
+, entropy
+, exceptions
+, fetchgit
+, hspec
+, hspec-discover
+, http-api-data
+, http-client
+, http-media
+, http-types
+, HUnit
+, kan-extensions
+, lib
+, markdown-unlit
+, monad-control
+, mtl
+, network
+, QuickCheck
+, semigroupoids
+, servant
+, servant-client-core
+, servant-server
+, sop-core
+, stm
+, tdigest
+, text
+, time
+, transformers
+, transformers-base
+, transformers-compat
+, wai
+, warp
 }:
 mkDerivation {
   pname = "servant-client";
@@ -17,16 +48,55 @@ mkDerivation {
   };
   postUnpack = "sourceRoot+=/servant-client/; echo source root reset to $sourceRoot";
   libraryHaskellDepends = [
-    base base-compat bytestring containers deepseq exceptions
-    http-client http-media http-types kan-extensions monad-control mtl
-    semigroupoids servant servant-client-core stm text time
-    transformers transformers-base transformers-compat
+    base
+    base-compat
+    bytestring
+    containers
+    deepseq
+    exceptions
+    http-client
+    http-media
+    http-types
+    kan-extensions
+    monad-control
+    mtl
+    semigroupoids
+    servant
+    servant-client-core
+    stm
+    text
+    time
+    transformers
+    transformers-base
+    transformers-compat
   ];
   testHaskellDepends = [
-    aeson base base-compat bytestring entropy hspec http-api-data
-    http-client http-types HUnit kan-extensions markdown-unlit mtl
-    network QuickCheck servant servant-client-core servant-server
-    sop-core stm tdigest text transformers transformers-compat wai warp
+    aeson
+    base
+    base-compat
+    bytestring
+    entropy
+    hspec
+    http-api-data
+    http-client
+    http-types
+    HUnit
+    kan-extensions
+    markdown-unlit
+    mtl
+    network
+    QuickCheck
+    servant
+    servant-client-core
+    servant-server
+    sop-core
+    stm
+    tdigest
+    text
+    transformers
+    transformers-compat
+    wai
+    warp
   ];
   testToolDepends = [ hspec-discover markdown-unlit ];
   doHaddock = false;
@@ -36,4 +106,4 @@ mkDerivation {
   homepage = "http://docs.servant.dev/";
   description = "Automatic derivation of querying functions for servant";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/servant-foreign.nix b/pkgs/servant-foreign.nix
index e3b4ecacae3bc4df118fe3e39787ac8f493556e5..254868abc940c339f72dead0e98ef0e648ad590b 100644
--- a/pkgs/servant-foreign.nix
+++ b/pkgs/servant-foreign.nix
@@ -1,5 +1,14 @@
-{ mkDerivation, base, base-compat, fetchgit, hspec, hspec-discover
-, http-types, lens, lib, servant, text
+{ mkDerivation
+, base
+, base-compat
+, fetchgit
+, hspec
+, hspec-discover
+, http-types
+, lens
+, lib
+, servant
+, text
 }:
 mkDerivation {
   pname = "servant-foreign";
@@ -12,7 +21,12 @@ mkDerivation {
   };
   postUnpack = "sourceRoot+=/servant-foreign/; echo source root reset to $sourceRoot";
   libraryHaskellDepends = [
-    base base-compat http-types lens servant text
+    base
+    base-compat
+    http-types
+    lens
+    servant
+    text
   ];
   testHaskellDepends = [ base hspec servant ];
   testToolDepends = [ hspec-discover ];
@@ -23,4 +37,4 @@ mkDerivation {
   homepage = "http://docs.servant.dev/";
   description = "Helpers for generating clients for servant APIs in any programming language";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/servant-lucid.nix b/pkgs/servant-lucid.nix
index 73967241c1dcdb9494e94d3271d9016d2c40b320..702260d9fa35cb29c1ff6b4ab6abbc8ddd43177d 100644
--- a/pkgs/servant-lucid.nix
+++ b/pkgs/servant-lucid.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, base, http-media, lib, lucid, servant
-, servant-server, text, wai, warp
+{ mkDerivation
+, base
+, http-media
+, lib
+, lucid
+, servant
+, servant-server
+, text
+, wai
+, warp
 }:
 mkDerivation {
   pname = "servant-lucid";
@@ -14,4 +22,4 @@ mkDerivation {
   homepage = "http://haskell-servant.readthedocs.org/";
   description = "Servant support for lucid";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/servant-multipart-api.nix b/pkgs/servant-multipart-api.nix
index 29f323c3dd8a5b227400b0827cfefbcb702c9f78..a77552165189abcb49a210601aa3b9e59c8c6f61 100644
--- a/pkgs/servant-multipart-api.nix
+++ b/pkgs/servant-multipart-api.nix
@@ -1,4 +1,10 @@
-{ mkDerivation, base, bytestring, lib, servant, text, transformers
+{ mkDerivation
+, base
+, bytestring
+, lib
+, servant
+, text
+, transformers
 }:
 mkDerivation {
   pname = "servant-multipart-api";
@@ -7,7 +13,11 @@ mkDerivation {
   revision = "3";
   editedCabalFile = "1zhiszjg8n37g25sh2cnw509n0v4b89fd93j466f2gzwkxfaaw0m";
   libraryHaskellDepends = [
-    base bytestring servant text transformers
+    base
+    bytestring
+    servant
+    text
+    transformers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -16,4 +26,4 @@ mkDerivation {
   homepage = "https://github.com/haskell-servant/servant-multipart#readme";
   description = "multipart/form-data (e.g file upload) support for servant";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/servant-multipart.nix b/pkgs/servant-multipart.nix
index e62985fad06015f73db3aac05818008ec39e1fc7..1edc16d6a573020d06ba67917981917da5e009d3 100644
--- a/pkgs/servant-multipart.nix
+++ b/pkgs/servant-multipart.nix
@@ -1,7 +1,22 @@
-{ mkDerivation, base, bytestring, directory, http-types, lens, lib
-, resourcet, servant, servant-docs, servant-foreign
-, servant-multipart-api, servant-server, string-conversions, tasty
-, tasty-wai, text, wai, wai-extra
+{ mkDerivation
+, base
+, bytestring
+, directory
+, http-types
+, lens
+, lib
+, resourcet
+, servant
+, servant-docs
+, servant-foreign
+, servant-multipart-api
+, servant-server
+, string-conversions
+, tasty
+, tasty-wai
+, text
+, wai
+, wai-extra
 }:
 mkDerivation {
   pname = "servant-multipart";
@@ -10,13 +25,30 @@ mkDerivation {
   revision = "3";
   editedCabalFile = "1wkbwd6gypmv7aziaag3gzwgvvqx4bw8i4qp2vpmc7ip2ydm10ml";
   libraryHaskellDepends = [
-    base bytestring directory lens resourcet servant servant-docs
-    servant-foreign servant-multipart-api servant-server
-    string-conversions text wai wai-extra
+    base
+    bytestring
+    directory
+    lens
+    resourcet
+    servant
+    servant-docs
+    servant-foreign
+    servant-multipart-api
+    servant-server
+    string-conversions
+    text
+    wai
+    wai-extra
   ];
   testHaskellDepends = [
-    base bytestring http-types servant-server string-conversions tasty
-    tasty-wai text
+    base
+    bytestring
+    http-types
+    servant-server
+    string-conversions
+    tasty
+    tasty-wai
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -25,4 +57,4 @@ mkDerivation {
   homepage = "https://github.com/haskell-servant/servant-multipart#readme";
   description = "multipart/form-data (e.g file upload) support for servant";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/servant.nix b/pkgs/servant.nix
index d9552c740ad4b5753268f2ea78e66df02286f7cb..76f7bdc59f36f7dbb48b397f2a8ddea1dce25b64 100644
--- a/pkgs/servant.nix
+++ b/pkgs/servant.nix
@@ -1,9 +1,32 @@
-{ mkDerivation, aeson, attoparsec, base, base-compat, bifunctors
-, bytestring, case-insensitive, constraints, deepseq, fetchgit
-, hspec, hspec-discover, http-api-data, http-media, http-types, lib
-, mmorph, mtl, network-uri, QuickCheck, quickcheck-instances
-, singleton-bool, sop-core, string-conversions, tagged, text
-, transformers, vault
+{ mkDerivation
+, aeson
+, attoparsec
+, base
+, base-compat
+, bifunctors
+, bytestring
+, case-insensitive
+, constraints
+, deepseq
+, fetchgit
+, hspec
+, hspec-discover
+, http-api-data
+, http-media
+, http-types
+, lib
+, mmorph
+, mtl
+, network-uri
+, QuickCheck
+, quickcheck-instances
+, singleton-bool
+, sop-core
+, string-conversions
+, tagged
+, text
+, transformers
+, vault
 }:
 mkDerivation {
   pname = "servant";
@@ -16,14 +39,43 @@ mkDerivation {
   };
   postUnpack = "sourceRoot+=/servant/; echo source root reset to $sourceRoot";
   libraryHaskellDepends = [
-    aeson attoparsec base base-compat bifunctors bytestring
-    case-insensitive constraints deepseq http-api-data http-media
-    http-types mmorph mtl network-uri QuickCheck singleton-bool
-    sop-core string-conversions tagged text transformers vault
+    aeson
+    attoparsec
+    base
+    base-compat
+    bifunctors
+    bytestring
+    case-insensitive
+    constraints
+    deepseq
+    http-api-data
+    http-media
+    http-types
+    mmorph
+    mtl
+    network-uri
+    QuickCheck
+    singleton-bool
+    sop-core
+    string-conversions
+    tagged
+    text
+    transformers
+    vault
   ];
   testHaskellDepends = [
-    aeson base base-compat bytestring hspec http-media mtl QuickCheck
-    quickcheck-instances string-conversions text transformers
+    aeson
+    base
+    base-compat
+    bytestring
+    hspec
+    http-media
+    mtl
+    QuickCheck
+    quickcheck-instances
+    string-conversions
+    text
+    transformers
   ];
   testToolDepends = [ hspec-discover ];
   doHaddock = false;
@@ -33,4 +85,4 @@ mkDerivation {
   homepage = "http://docs.servant.dev/";
   description = "A family of combinators for defining webservices APIs";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/shake.nix b/pkgs/shake.nix
index 974040691f42c110ef8eaa23b314d345c1c91454..3fbe12c6af86c4f4bc48ecf21699ae65a7ddd70a 100644
--- a/pkgs/shake.nix
+++ b/pkgs/shake.nix
@@ -1,7 +1,27 @@
-{ mkDerivation, base, binary, bytestring, deepseq, directory, extra
-, filepath, filepattern, hashable, heaps, js-dgtable, js-flot
-, js-jquery, lib, primitive, process, QuickCheck, random, time
-, transformers, unix, unordered-containers, utf8-string
+{ mkDerivation
+, base
+, binary
+, bytestring
+, deepseq
+, directory
+, extra
+, filepath
+, filepattern
+, hashable
+, heaps
+, js-dgtable
+, js-flot
+, js-jquery
+, lib
+, primitive
+, process
+, QuickCheck
+, random
+, time
+, transformers
+, unix
+, unordered-containers
+, utf8-string
 }:
 mkDerivation {
   pname = "shake";
@@ -11,19 +31,73 @@ mkDerivation {
   isExecutable = true;
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
-    base binary bytestring deepseq directory extra filepath filepattern
-    hashable heaps js-dgtable js-flot js-jquery primitive process
-    random time transformers unix unordered-containers utf8-string
+    base
+    binary
+    bytestring
+    deepseq
+    directory
+    extra
+    filepath
+    filepattern
+    hashable
+    heaps
+    js-dgtable
+    js-flot
+    js-jquery
+    primitive
+    process
+    random
+    time
+    transformers
+    unix
+    unordered-containers
+    utf8-string
   ];
   executableHaskellDepends = [
-    base binary bytestring deepseq directory extra filepath filepattern
-    hashable heaps js-dgtable js-flot js-jquery primitive process
-    random time transformers unix unordered-containers utf8-string
+    base
+    binary
+    bytestring
+    deepseq
+    directory
+    extra
+    filepath
+    filepattern
+    hashable
+    heaps
+    js-dgtable
+    js-flot
+    js-jquery
+    primitive
+    process
+    random
+    time
+    transformers
+    unix
+    unordered-containers
+    utf8-string
   ];
   testHaskellDepends = [
-    base binary bytestring deepseq directory extra filepath filepattern
-    hashable heaps js-dgtable js-flot js-jquery primitive process
-    QuickCheck random time transformers unix unordered-containers
+    base
+    binary
+    bytestring
+    deepseq
+    directory
+    extra
+    filepath
+    filepattern
+    hashable
+    heaps
+    js-dgtable
+    js-flot
+    js-jquery
+    primitive
+    process
+    QuickCheck
+    random
+    time
+    transformers
+    unix
+    unordered-containers
     utf8-string
   ];
   doHaddock = false;
@@ -34,4 +108,4 @@ mkDerivation {
   description = "Build system library, like Make, but more accurate dependencies";
   license = lib.licenses.bsd3;
   mainProgram = "shake";
-}
\ No newline at end of file
+}
diff --git a/pkgs/shelly.nix b/pkgs/shelly.nix
index 12fc477a429f91a82e3bae9549d3a6dfae4e85b3..f195e6ee89947e6af7c0838ae71e2b14ee1bd7b5 100644
--- a/pkgs/shelly.nix
+++ b/pkgs/shelly.nix
@@ -1,7 +1,26 @@
-{ mkDerivation, async, base, bytestring, containers, directory
-, enclosed-exceptions, exceptions, filepath, hspec, hspec-contrib
-, HUnit, lib, lifted-async, lifted-base, monad-control, mtl
-, process, text, time, transformers, transformers-base, unix-compat
+{ mkDerivation
+, async
+, base
+, bytestring
+, containers
+, directory
+, enclosed-exceptions
+, exceptions
+, filepath
+, hspec
+, hspec-contrib
+, HUnit
+, lib
+, lifted-async
+, lifted-base
+, monad-control
+, mtl
+, process
+, text
+, time
+, transformers
+, transformers-base
+, unix-compat
 }:
 mkDerivation {
   pname = "shelly";
@@ -12,13 +31,38 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    async base bytestring containers directory enclosed-exceptions
-    exceptions filepath lifted-async lifted-base monad-control mtl
-    process text time transformers transformers-base unix-compat
+    async
+    base
+    bytestring
+    containers
+    directory
+    enclosed-exceptions
+    exceptions
+    filepath
+    lifted-async
+    lifted-base
+    monad-control
+    mtl
+    process
+    text
+    time
+    transformers
+    transformers-base
+    unix-compat
   ];
   testHaskellDepends = [
-    base bytestring directory filepath hspec hspec-contrib HUnit
-    lifted-async mtl text transformers unix-compat
+    base
+    bytestring
+    directory
+    filepath
+    hspec
+    hspec-contrib
+    HUnit
+    lifted-async
+    mtl
+    text
+    transformers
+    unix-compat
   ];
   doHaddock = false;
   jailbreak = true;
@@ -27,4 +71,4 @@ mkDerivation {
   homepage = "https://github.com/yesodweb/Shelly.hs";
   description = "shell-like (systems) programming in Haskell";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/singleton-bool.nix b/pkgs/singleton-bool.nix
index e1aa76ab7f4a891ddfcf82d0c5e97e3e27dd22c7..095b8cc3d8044184a72d931d0ca473d70d8e7f89 100644
--- a/pkgs/singleton-bool.nix
+++ b/pkgs/singleton-bool.nix
@@ -13,4 +13,4 @@ mkDerivation {
   homepage = "https://github.com/phadej/singleton-bool#readme";
   description = "Type level booleans";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/singletons.nix b/pkgs/singletons.nix
index 5eadbe6114fc38ac43385166e8898eb7aa23e49d..0e47c5e875de04542940380c8a4d3d2be933204e 100644
--- a/pkgs/singletons.nix
+++ b/pkgs/singletons.nix
@@ -12,4 +12,4 @@ mkDerivation {
   homepage = "http://www.github.com/goldfirere/singletons";
   description = "Basic singleton types and definitions";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/some.nix b/pkgs/some.nix
index 574eb8543e714e497cde3bfeea90f7a0f8fd13ac..7e0599d8f338230cb868a7db6ddaddaccacb039b 100644
--- a/pkgs/some.nix
+++ b/pkgs/some.nix
@@ -14,4 +14,4 @@ mkDerivation {
   homepage = "https://github.com/haskellari/some";
   description = "Existential type: Some";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/sop-core.nix b/pkgs/sop-core.nix
index bd1836785231f6860ca9b90d275532da0ef3b701..5629df14322625fce6e4e265b4a0376f78f4dce8 100644
--- a/pkgs/sop-core.nix
+++ b/pkgs/sop-core.nix
@@ -12,4 +12,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "True Sums of Products";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/split.nix b/pkgs/split.nix
index f6d1ffffef44b2082583f21757c45a05c462ef66..02218df23bed06cb77300e1287e363e729547b53 100644
--- a/pkgs/split.nix
+++ b/pkgs/split.nix
@@ -13,4 +13,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Combinator library for splitting lists";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/streaming-commons.nix b/pkgs/streaming-commons.nix
index 802808aeb42815970bbd095e57ae0cb20fade5e7..0bd01eee8579912f701b2ff1736ef320614e9321 100644
--- a/pkgs/streaming-commons.nix
+++ b/pkgs/streaming-commons.nix
@@ -1,18 +1,54 @@
-{ mkDerivation, array, async, base, bytestring, deepseq, directory
-, gauge, hspec, lib, network, process, QuickCheck, random, stm
-, text, transformers, unix, zlib
+{ mkDerivation
+, array
+, async
+, base
+, bytestring
+, deepseq
+, directory
+, gauge
+, hspec
+, lib
+, network
+, process
+, QuickCheck
+, random
+, stm
+, text
+, transformers
+, unix
+, zlib
 }:
 mkDerivation {
   pname = "streaming-commons";
   version = "0.2.2.4";
   sha256 = "56a1408cce710cddfb04d73757efba439c98fb8043515083a45136902214ccf2";
   libraryHaskellDepends = [
-    array async base bytestring directory network process random stm
-    text transformers unix zlib
+    array
+    async
+    base
+    bytestring
+    directory
+    network
+    process
+    random
+    stm
+    text
+    transformers
+    unix
+    zlib
   ];
   testHaskellDepends = [
-    array async base bytestring deepseq hspec network QuickCheck text
-    unix zlib
+    array
+    async
+    base
+    bytestring
+    deepseq
+    hspec
+    network
+    QuickCheck
+    text
+    unix
+    zlib
   ];
   benchmarkHaskellDepends = [ base bytestring deepseq gauge text ];
   doHaddock = false;
@@ -22,4 +58,4 @@ mkDerivation {
   homepage = "https://github.com/fpco/streaming-commons";
   description = "Common lower-level functions needed by various streaming data libraries";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/string-interpolate.nix b/pkgs/string-interpolate.nix
index e4f8a076589244eaa5658db94c2553361af4fbcd..9a500ab499b0aaf185d8af61bab46766a8929d65 100644
--- a/pkgs/string-interpolate.nix
+++ b/pkgs/string-interpolate.nix
@@ -1,8 +1,25 @@
-{ mkDerivation, base, bytestring, criterion, deepseq, formatting
-, haskell-src-exts, haskell-src-meta, hspec, hspec-core
-, interpolate, lib, neat-interpolation, QuickCheck
-, quickcheck-instances, quickcheck-text, quickcheck-unicode, split
-, template-haskell, text, text-conversions, unordered-containers
+{ mkDerivation
+, base
+, bytestring
+, criterion
+, deepseq
+, formatting
+, haskell-src-exts
+, haskell-src-meta
+, hspec
+, hspec-core
+, interpolate
+, lib
+, neat-interpolation
+, QuickCheck
+, quickcheck-instances
+, quickcheck-text
+, quickcheck-unicode
+, split
+, template-haskell
+, text
+, text-conversions
+, unordered-containers
 , utf8-string
 }:
 mkDerivation {
@@ -12,17 +29,39 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "1nrpng7r59a25z4qns8vy26rvp1wgn5f4bs8ism40q66ags8f2ad";
   libraryHaskellDepends = [
-    base bytestring haskell-src-exts haskell-src-meta split
-    template-haskell text text-conversions utf8-string
+    base
+    bytestring
+    haskell-src-exts
+    haskell-src-meta
+    split
+    template-haskell
+    text
+    text-conversions
+    utf8-string
   ];
   testHaskellDepends = [
-    base bytestring hspec hspec-core QuickCheck quickcheck-instances
-    quickcheck-text quickcheck-unicode template-haskell text
+    base
+    bytestring
+    hspec
+    hspec-core
+    QuickCheck
+    quickcheck-instances
+    quickcheck-text
+    quickcheck-unicode
+    template-haskell
+    text
     unordered-containers
   ];
   benchmarkHaskellDepends = [
-    base bytestring criterion deepseq formatting interpolate
-    neat-interpolation QuickCheck text
+    base
+    bytestring
+    criterion
+    deepseq
+    formatting
+    interpolate
+    neat-interpolation
+    QuickCheck
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -31,4 +70,4 @@ mkDerivation {
   homepage = "https://gitlab.com/williamyaoh/string-interpolate/blob/master/README.md";
   description = "Haskell string/text/bytestring interpolation that just works";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/string-qq.nix b/pkgs/string-qq.nix
index dcabc97ce40b2aaeae2ae3f3923a756bb9933e00..76beb9d32bfd82d90563d2f3f868dd7056e3d97b 100644
--- a/pkgs/string-qq.nix
+++ b/pkgs/string-qq.nix
@@ -11,4 +11,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "QuasiQuoter for non-interpolated strings, texts and bytestrings";
   license = lib.licenses.publicDomain;
-}
\ No newline at end of file
+}
diff --git a/pkgs/stylish-haskell.nix b/pkgs/stylish-haskell.nix
index a4825ea7cc8b73b3c5492cc9f16676160b926494..0aa2ac9e099b892fe431b5470c5b4370a9b44597 100644
--- a/pkgs/stylish-haskell.nix
+++ b/pkgs/stylish-haskell.nix
@@ -1,8 +1,28 @@
-{ mkDerivation, aeson, base, bytestring, Cabal, containers
-, directory, file-embed, filepath, ghc, ghc-boot, ghc-boot-th
-, ghc-lib-parser-ex, HsYAML, HsYAML-aeson, HUnit, lib, mtl
-, optparse-applicative, random, strict, syb, test-framework
-, test-framework-hunit, text
+{ mkDerivation
+, aeson
+, base
+, bytestring
+, Cabal
+, containers
+, directory
+, file-embed
+, filepath
+, ghc
+, ghc-boot
+, ghc-boot-th
+, ghc-lib-parser-ex
+, HsYAML
+, HsYAML-aeson
+, HUnit
+, lib
+, mtl
+, optparse-applicative
+, random
+, strict
+, syb
+, test-framework
+, test-framework-hunit
+, text
 }:
 mkDerivation {
   pname = "stylish-haskell";
@@ -11,20 +31,67 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    aeson base bytestring Cabal containers directory file-embed
-    filepath ghc ghc-boot ghc-boot-th ghc-lib-parser-ex HsYAML
-    HsYAML-aeson mtl syb text
+    aeson
+    base
+    bytestring
+    Cabal
+    containers
+    directory
+    file-embed
+    filepath
+    ghc
+    ghc-boot
+    ghc-boot-th
+    ghc-lib-parser-ex
+    HsYAML
+    HsYAML-aeson
+    mtl
+    syb
+    text
   ];
   executableHaskellDepends = [
-    aeson base bytestring Cabal containers directory file-embed
-    filepath ghc ghc-boot ghc-boot-th ghc-lib-parser-ex HsYAML
-    HsYAML-aeson mtl optparse-applicative strict syb text
+    aeson
+    base
+    bytestring
+    Cabal
+    containers
+    directory
+    file-embed
+    filepath
+    ghc
+    ghc-boot
+    ghc-boot-th
+    ghc-lib-parser-ex
+    HsYAML
+    HsYAML-aeson
+    mtl
+    optparse-applicative
+    strict
+    syb
+    text
   ];
   testHaskellDepends = [
-    aeson base bytestring Cabal containers directory file-embed
-    filepath ghc ghc-boot ghc-boot-th ghc-lib-parser-ex HsYAML
-    HsYAML-aeson HUnit mtl random syb test-framework
-    test-framework-hunit text
+    aeson
+    base
+    bytestring
+    Cabal
+    containers
+    directory
+    file-embed
+    filepath
+    ghc
+    ghc-boot
+    ghc-boot-th
+    ghc-lib-parser-ex
+    HsYAML
+    HsYAML-aeson
+    HUnit
+    mtl
+    random
+    syb
+    test-framework
+    test-framework-hunit
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -34,4 +101,4 @@ mkDerivation {
   description = "Haskell code prettifier";
   license = lib.licenses.bsd3;
   mainProgram = "stylish-haskell";
-}
\ No newline at end of file
+}
diff --git a/pkgs/syb.nix b/pkgs/syb.nix
index b2e3f8fac4e57beb69b30ecbcc654cf75e394706..6baf6b4c813fc3a02aab33894b0e7ee2205a314b 100644
--- a/pkgs/syb.nix
+++ b/pkgs/syb.nix
@@ -12,4 +12,4 @@ mkDerivation {
   homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB";
   description = "Scrap Your Boilerplate";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/sydtest-discover.nix b/pkgs/sydtest-discover.nix
index 74245e55731d2462ad454526fd457d278bc26fe6..f16a3bb6313f2408f6e9e8e6c84745c9e5832044 100644
--- a/pkgs/sydtest-discover.nix
+++ b/pkgs/sydtest-discover.nix
@@ -1,4 +1,9 @@
-{ mkDerivation, base, filepath, lib, optparse-applicative, path
+{ mkDerivation
+, base
+, filepath
+, lib
+, optparse-applicative
+, path
 , path-io
 }:
 mkDerivation {
@@ -8,7 +13,11 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base filepath optparse-applicative path path-io
+    base
+    filepath
+    optparse-applicative
+    path
+    path-io
   ];
   executableHaskellDepends = [ base ];
   doHaddock = false;
@@ -19,4 +28,4 @@ mkDerivation {
   description = "Automatic test suite discovery for sydtest";
   license = "unknown";
   mainProgram = "sydtest-discover";
-}
\ No newline at end of file
+}
diff --git a/pkgs/sydtest.nix b/pkgs/sydtest.nix
index b9ad221c37f7542e38d552b8f2aeb23e6b88206d..3df70cbba007f6ad7f469c04bd0adbcc44ba7ffd 100644
--- a/pkgs/sydtest.nix
+++ b/pkgs/sydtest.nix
@@ -1,23 +1,75 @@
-{ mkDerivation, async, autodocodec, autodocodec-yaml, base
-, bytestring, containers, Diff, dlist, envparse, filepath, lib
-, MonadRandom, mtl, optparse-applicative, path, path-io
-, pretty-show, QuickCheck, quickcheck-io, random, random-shuffle
-, safe, safe-coloured-text, safe-coloured-text-terminfo, split, stm
-, sydtest-discover, text
+{ mkDerivation
+, async
+, autodocodec
+, autodocodec-yaml
+, base
+, bytestring
+, containers
+, Diff
+, dlist
+, envparse
+, filepath
+, lib
+, MonadRandom
+, mtl
+, optparse-applicative
+, path
+, path-io
+, pretty-show
+, QuickCheck
+, quickcheck-io
+, random
+, random-shuffle
+, safe
+, safe-coloured-text
+, safe-coloured-text-terminfo
+, split
+, stm
+, sydtest-discover
+, text
 }:
 mkDerivation {
   pname = "sydtest";
   version = "0.12.0.1";
   sha256 = "1c7186d0e41145aefcb6eae9727938d757e07ebd8f8287feb19a447567d8565f";
   libraryHaskellDepends = [
-    async autodocodec autodocodec-yaml base bytestring containers Diff
-    dlist envparse filepath MonadRandom mtl optparse-applicative path
-    path-io pretty-show QuickCheck quickcheck-io random random-shuffle
-    safe safe-coloured-text safe-coloured-text-terminfo split stm text
+    async
+    autodocodec
+    autodocodec-yaml
+    base
+    bytestring
+    containers
+    Diff
+    dlist
+    envparse
+    filepath
+    MonadRandom
+    mtl
+    optparse-applicative
+    path
+    path-io
+    pretty-show
+    QuickCheck
+    quickcheck-io
+    random
+    random-shuffle
+    safe
+    safe-coloured-text
+    safe-coloured-text-terminfo
+    split
+    stm
+    text
   ];
   testHaskellDepends = [
-    base bytestring path path-io QuickCheck random safe-coloured-text
-    stm text
+    base
+    bytestring
+    path
+    path-io
+    QuickCheck
+    random
+    safe-coloured-text
+    stm
+    text
   ];
   testToolDepends = [ sydtest-discover ];
   doHaddock = false;
@@ -27,4 +79,4 @@ mkDerivation {
   homepage = "https://github.com/NorfairKing/sydtest#readme";
   description = "A modern testing framework for Haskell with good defaults and advanced testing features";
   license = "unknown";
-}
\ No newline at end of file
+}
diff --git a/pkgs/tasty-discover.nix b/pkgs/tasty-discover.nix
index c5ec1ef3c5f274a5de2f900c0e3998ab15728f54..e03846d27878b6bcee471395683846646606d27b 100644
--- a/pkgs/tasty-discover.nix
+++ b/pkgs/tasty-discover.nix
@@ -1,6 +1,20 @@
-{ mkDerivation, base, bytestring, containers, directory, filepath
-, Glob, hedgehog, hspec, hspec-core, lib, tasty, tasty-golden
-, tasty-hedgehog, tasty-hspec, tasty-hunit, tasty-quickcheck
+{ mkDerivation
+, base
+, bytestring
+, containers
+, directory
+, filepath
+, Glob
+, hedgehog
+, hspec
+, hspec-core
+, lib
+, tasty
+, tasty-golden
+, tasty-hedgehog
+, tasty-hspec
+, tasty-hunit
+, tasty-quickcheck
 , tasty-smallcheck
 }:
 mkDerivation {
@@ -12,15 +26,37 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base containers directory filepath Glob tasty
+    base
+    containers
+    directory
+    filepath
+    Glob
+    tasty
   ];
   executableHaskellDepends = [
-    base containers directory filepath Glob
+    base
+    containers
+    directory
+    filepath
+    Glob
   ];
   testHaskellDepends = [
-    base bytestring containers directory filepath Glob hedgehog hspec
-    hspec-core tasty tasty-golden tasty-hedgehog tasty-hspec
-    tasty-hunit tasty-quickcheck tasty-smallcheck
+    base
+    bytestring
+    containers
+    directory
+    filepath
+    Glob
+    hedgehog
+    hspec
+    hspec-core
+    tasty
+    tasty-golden
+    tasty-hedgehog
+    tasty-hspec
+    tasty-hunit
+    tasty-quickcheck
+    tasty-smallcheck
   ];
   doHaddock = false;
   jailbreak = true;
@@ -30,4 +66,4 @@ mkDerivation {
   description = "Test discovery for the tasty framework";
   license = lib.licenses.mit;
   mainProgram = "tasty-discover";
-}
\ No newline at end of file
+}
diff --git a/pkgs/tasty-hedgehog.nix b/pkgs/tasty-hedgehog.nix
index 33af52b9bd1502119184a029ac9e38ff29f0b0b1..d695a0ee65ed4fe38720a14a829d8fe9ea711605 100644
--- a/pkgs/tasty-hedgehog.nix
+++ b/pkgs/tasty-hedgehog.nix
@@ -1,4 +1,10 @@
-{ mkDerivation, base, fetchgit, hedgehog, lib, tagged, tasty
+{ mkDerivation
+, base
+, fetchgit
+, hedgehog
+, lib
+, tagged
+, tasty
 , tasty-expected-failure
 }:
 mkDerivation {
@@ -12,7 +18,10 @@ mkDerivation {
   };
   libraryHaskellDepends = [ base hedgehog tagged tasty ];
   testHaskellDepends = [
-    base hedgehog tasty tasty-expected-failure
+    base
+    hedgehog
+    tasty
+    tasty-expected-failure
   ];
   doHaddock = false;
   jailbreak = true;
@@ -21,4 +30,4 @@ mkDerivation {
   homepage = "https://github.com/qfpl/tasty-hedgehog";
   description = "Integration for tasty and hedgehog";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/tasty-hunit.nix b/pkgs/tasty-hunit.nix
index 67d7225e9a2d618a3b77a8085c65a4d0181958bc..6e06d75b74c6054cd0c5bceba240688bb033bd11 100644
--- a/pkgs/tasty-hunit.nix
+++ b/pkgs/tasty-hunit.nix
@@ -17,4 +17,4 @@ mkDerivation {
   homepage = "https://github.com/UnkindPartition/tasty";
   description = "HUnit support for the Tasty test framework";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/tasty-wai.nix b/pkgs/tasty-wai.nix
index 39c3ec682ddb3ab4c7017fe8fa307e5a833b2fa6..871d6f2cc518bb432bee9843f3821b1bf5b38614 100644
--- a/pkgs/tasty-wai.nix
+++ b/pkgs/tasty-wai.nix
@@ -1,12 +1,25 @@
-{ mkDerivation, base, bytestring, http-types, HUnit, lib, tasty
-, wai, wai-extra
+{ mkDerivation
+, base
+, bytestring
+, http-types
+, HUnit
+, lib
+, tasty
+, wai
+, wai-extra
 }:
 mkDerivation {
   pname = "tasty-wai";
   version = "0.1.2.0";
   sha256 = "6f6f224d6dee893ce550f512832389a9ae0e490917a99b5362c9a4f73f16dca3";
   libraryHaskellDepends = [
-    base bytestring http-types HUnit tasty wai wai-extra
+    base
+    bytestring
+    http-types
+    HUnit
+    tasty
+    wai
+    wai-extra
   ];
   testHaskellDepends = [ base http-types tasty wai ];
   doHaddock = false;
@@ -15,4 +28,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Test 'wai' endpoints via Test.Tasty";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/tasty.nix b/pkgs/tasty.nix
index 0b2b54fe4902156d45aa5b76b3bc0ba1ad1e9225..fc9bb65f77a9051fd479a4cf8f8888b17f93d33e 100644
--- a/pkgs/tasty.nix
+++ b/pkgs/tasty.nix
@@ -1,5 +1,14 @@
-{ mkDerivation, ansi-terminal, base, containers, fetchgit, lib
-, optparse-applicative, stm, tagged, transformers, unix
+{ mkDerivation
+, ansi-terminal
+, base
+, containers
+, fetchgit
+, lib
+, optparse-applicative
+, stm
+, tagged
+, transformers
+, unix
 }:
 mkDerivation {
   pname = "tasty";
@@ -12,8 +21,14 @@ mkDerivation {
   };
   postUnpack = "sourceRoot+=/core/; echo source root reset to $sourceRoot";
   libraryHaskellDepends = [
-    ansi-terminal base containers optparse-applicative stm tagged
-    transformers unix
+    ansi-terminal
+    base
+    containers
+    optparse-applicative
+    stm
+    tagged
+    transformers
+    unix
   ];
   doHaddock = false;
   jailbreak = true;
@@ -22,4 +37,4 @@ mkDerivation {
   homepage = "https://github.com/UnkindPartition/tasty";
   description = "Modern and extensible testing framework";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/text-zipper.nix b/pkgs/text-zipper.nix
index 0d4ae2845dd3c0b13a09219b0f27d8fc1288ad4a..e93a95f69720e231faa2b75a95a327ea1395b8f1 100644
--- a/pkgs/text-zipper.nix
+++ b/pkgs/text-zipper.nix
@@ -1,4 +1,11 @@
-{ mkDerivation, base, deepseq, hspec, lib, QuickCheck, text, vector
+{ mkDerivation
+, base
+, deepseq
+, hspec
+, lib
+, QuickCheck
+, text
+, vector
 }:
 mkDerivation {
   pname = "text-zipper";
@@ -14,4 +21,4 @@ mkDerivation {
   homepage = "https://github.com/jtdaugherty/text-zipper/";
   description = "A text editor zipper library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/th-extras.nix b/pkgs/th-extras.nix
index 61e7c69c3ba17cd3ed6842a67711164b1cda0f7e..c7d15fdf20c1c182aba0eb5fc622c2ebb3318d5f 100644
--- a/pkgs/th-extras.nix
+++ b/pkgs/th-extras.nix
@@ -1,4 +1,9 @@
-{ mkDerivation, base, containers, lib, syb, template-haskell
+{ mkDerivation
+, base
+, containers
+, lib
+, syb
+, template-haskell
 , th-abstraction
 }:
 mkDerivation {
@@ -6,7 +11,11 @@ mkDerivation {
   version = "0.0.0.6";
   sha256 = "02bf23940c0233a6ef6f61868e827ebd4554afe8d71cef2a1eb8e286a7f07c4a";
   libraryHaskellDepends = [
-    base containers syb template-haskell th-abstraction
+    base
+    containers
+    syb
+    template-haskell
+    th-abstraction
   ];
   doHaddock = false;
   jailbreak = true;
@@ -15,4 +24,4 @@ mkDerivation {
   homepage = "https://github.com/mokus0/th-extras";
   description = "A grab bag of functions for use with Template Haskell";
   license = lib.licenses.publicDomain;
-}
\ No newline at end of file
+}
diff --git a/pkgs/th-lift-instances.nix b/pkgs/th-lift-instances.nix
index d75ef237b3c99a3ad25a5479efa10910775fda6b..ac155b86a258311dbf30761a309fa846a6cee017 100644
--- a/pkgs/th-lift-instances.nix
+++ b/pkgs/th-lift-instances.nix
@@ -1,16 +1,37 @@
-{ mkDerivation, base, bytestring, containers, lib, QuickCheck
-, template-haskell, text, th-lift, transformers, vector
+{ mkDerivation
+, base
+, bytestring
+, containers
+, lib
+, QuickCheck
+, template-haskell
+, text
+, th-lift
+, transformers
+, vector
 }:
 mkDerivation {
   pname = "th-lift-instances";
   version = "0.1.20";
   sha256 = "f533c3f95addcca461a0ccd1aafef75dd801bfa6599c0d1184d54bfffb61d870";
   libraryHaskellDepends = [
-    base bytestring containers template-haskell text th-lift
-    transformers vector
+    base
+    bytestring
+    containers
+    template-haskell
+    text
+    th-lift
+    transformers
+    vector
   ];
   testHaskellDepends = [
-    base bytestring containers QuickCheck template-haskell text vector
+    base
+    bytestring
+    containers
+    QuickCheck
+    template-haskell
+    text
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -19,4 +40,4 @@ mkDerivation {
   homepage = "http://github.com/bennofs/th-lift-instances/";
   description = "Lift instances for template-haskell for common data types";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/these.nix b/pkgs/these.nix
index cbf481c1b15c5ad98163387b181e4ad0724b9e66..716277969cce46a106f06098a082a83caab9f6a4 100644
--- a/pkgs/these.nix
+++ b/pkgs/these.nix
@@ -13,4 +13,4 @@ mkDerivation {
   homepage = "https://github.com/haskellari/these";
   description = "An either-or-both data type";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/tidal.nix b/pkgs/tidal.nix
index 8ec0e9cadcfd8290fa6a2fa4f57bde4af08f499a..bffe676f34c63fd9e1fb85695d3f19600e6f9d28 100644
--- a/pkgs/tidal.nix
+++ b/pkgs/tidal.nix
@@ -1,6 +1,23 @@
-{ mkDerivation, base, bifunctors, bytestring, clock, colour
-, containers, criterion, deepseq, exceptions, hosc, lib, microspec
-, mtl, network, parsec, primitive, random, text, transformers
+{ mkDerivation
+, base
+, bifunctors
+, bytestring
+, clock
+, colour
+, containers
+, criterion
+, deepseq
+, exceptions
+, hosc
+, lib
+, microspec
+, mtl
+, network
+, parsec
+, primitive
+, random
+, text
+, transformers
 , weigh
 }:
 mkDerivation {
@@ -11,12 +28,30 @@ mkDerivation {
   editedCabalFile = "0mnxl1ynxf2cgqlrbkshw8qngiw7b6lf0lsjkd6hjhkh2xbxgxzx";
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
-    base bifunctors bytestring clock colour containers deepseq
-    exceptions hosc mtl network parsec primitive random text
+    base
+    bifunctors
+    bytestring
+    clock
+    colour
+    containers
+    deepseq
+    exceptions
+    hosc
+    mtl
+    network
+    parsec
+    primitive
+    random
+    text
     transformers
   ];
   testHaskellDepends = [
-    base containers deepseq hosc microspec parsec
+    base
+    containers
+    deepseq
+    hosc
+    microspec
+    parsec
   ];
   benchmarkHaskellDepends = [ base criterion weigh ];
   doHaddock = false;
@@ -26,4 +61,4 @@ mkDerivation {
   homepage = "http://tidalcycles.org/";
   description = "Pattern language for improvised music";
   license = lib.licenses.gpl3Only;
-}
\ No newline at end of file
+}
diff --git a/pkgs/time-compat.nix b/pkgs/time-compat.nix
index 6da68b9a6f3e500a7612c4ecd016bed94f89200c..6e2431480ba6b320eb2dbe9d1ac499565290056c 100644
--- a/pkgs/time-compat.nix
+++ b/pkgs/time-compat.nix
@@ -1,6 +1,17 @@
-{ mkDerivation, base, base-compat, base-orphans, deepseq, hashable
-, HUnit, lib, QuickCheck, tagged, tasty, tasty-hunit
-, tasty-quickcheck, time
+{ mkDerivation
+, base
+, base-compat
+, base-orphans
+, deepseq
+, hashable
+, HUnit
+, lib
+, QuickCheck
+, tagged
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, time
 }:
 mkDerivation {
   pname = "time-compat";
@@ -9,11 +20,24 @@ mkDerivation {
   revision = "4";
   editedCabalFile = "1n39yfk21xz8y1xvkh01651yysk2zp5qac22l5pq2hi7scczmxaw";
   libraryHaskellDepends = [
-    base base-orphans deepseq hashable time
+    base
+    base-orphans
+    deepseq
+    hashable
+    time
   ];
   testHaskellDepends = [
-    base base-compat deepseq hashable HUnit QuickCheck tagged tasty
-    tasty-hunit tasty-quickcheck time
+    base
+    base-compat
+    deepseq
+    hashable
+    HUnit
+    QuickCheck
+    tagged
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    time
   ];
   doHaddock = false;
   jailbreak = true;
@@ -22,4 +46,4 @@ mkDerivation {
   homepage = "https://github.com/haskellari/time-compat";
   description = "Compatibility package for time";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/type-equality.nix b/pkgs/type-equality.nix
index 90988d2b04610b8a67a6a6277f741b47f4475c80..ff355c8be651924f077bc24e97cb0715906c110d 100644
--- a/pkgs/type-equality.nix
+++ b/pkgs/type-equality.nix
@@ -13,4 +13,4 @@ mkDerivation {
   homepage = "https://github.com/hesselink/type-equality";
   description = "Data.Type.Equality compat package";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/type-errors-pretty.nix b/pkgs/type-errors-pretty.nix
index a2c3a7323be0b3838e447a6e1db8c6dd504c0490..b4578211384a2fac096bcb80f098f8f9636a4866 100644
--- a/pkgs/type-errors-pretty.nix
+++ b/pkgs/type-errors-pretty.nix
@@ -12,4 +12,4 @@ mkDerivation {
   homepage = "https://github.com/kowainik/type-errors-pretty";
   description = "Combinators for writing pretty type errors easily";
   license = lib.licenses.mpl20;
-}
\ No newline at end of file
+}
diff --git a/pkgs/type-errors.nix b/pkgs/type-errors.nix
index 15600021cd52dd42b96cdfeedfb2f51b795ee937..9544ac1c4fbde3c6a633742a741b9c99fa59d788 100644
--- a/pkgs/type-errors.nix
+++ b/pkgs/type-errors.nix
@@ -1,5 +1,11 @@
-{ mkDerivation, base, doctest, first-class-families, lib, syb
-, template-haskell, th-abstraction
+{ mkDerivation
+, base
+, doctest
+, first-class-families
+, lib
+, syb
+, template-haskell
+, th-abstraction
 }:
 mkDerivation {
   pname = "type-errors";
@@ -8,10 +14,18 @@ mkDerivation {
   revision = "3";
   editedCabalFile = "0ig8qd2g8rd5n78039xhbq7n8r514f8kvbh0mgajav2a5lp549s1";
   libraryHaskellDepends = [
-    base first-class-families syb template-haskell th-abstraction
+    base
+    first-class-families
+    syb
+    template-haskell
+    th-abstraction
   ];
   testHaskellDepends = [
-    base doctest first-class-families syb template-haskell
+    base
+    doctest
+    first-class-families
+    syb
+    template-haskell
     th-abstraction
   ];
   doHaddock = false;
@@ -21,4 +35,4 @@ mkDerivation {
   homepage = "https://github.com/isovector/type-errors#readme";
   description = "Tools for writing better type errors";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/unicode-collation.nix b/pkgs/unicode-collation.nix
index 9e2c1cf6f9989b9e5cf56ea0ce3b3a46dfd0a63a..afd9f4e314076c1f0b587d61010c1fbbcbf478a4 100644
--- a/pkgs/unicode-collation.nix
+++ b/pkgs/unicode-collation.nix
@@ -1,7 +1,21 @@
-{ mkDerivation, base, binary, bytestring, containers, lib, parsec
-, QuickCheck, quickcheck-instances, tasty, tasty-bench, tasty-hunit
-, tasty-quickcheck, template-haskell, text, text-icu
-, th-lift-instances, unicode-transforms
+{ mkDerivation
+, base
+, binary
+, bytestring
+, containers
+, lib
+, parsec
+, QuickCheck
+, quickcheck-instances
+, tasty
+, tasty-bench
+, tasty-hunit
+, tasty-quickcheck
+, template-haskell
+, text
+, text-icu
+, th-lift-instances
+, unicode-transforms
 }:
 mkDerivation {
   pname = "unicode-collation";
@@ -10,15 +24,31 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base binary bytestring containers parsec template-haskell text
+    base
+    binary
+    bytestring
+    containers
+    parsec
+    template-haskell
+    text
     th-lift-instances
   ];
   testHaskellDepends = [
-    base bytestring tasty tasty-hunit tasty-quickcheck text
+    base
+    bytestring
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    text
     unicode-transforms
   ];
   benchmarkHaskellDepends = [
-    base QuickCheck quickcheck-instances tasty-bench text text-icu
+    base
+    QuickCheck
+    quickcheck-instances
+    tasty-bench
+    text
+    text-icu
   ];
   doHaddock = false;
   jailbreak = true;
@@ -27,4 +57,4 @@ mkDerivation {
   homepage = "https://github.com/jgm/unicode-collation";
   description = "Haskell implementation of the Unicode Collation Algorithm";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+}
diff --git a/pkgs/unicode-data.nix b/pkgs/unicode-data.nix
index beea50fe0c784155ca96aacb6c201753349a0633..91b49480afdfb2a898f48590ace8236099a830e0 100644
--- a/pkgs/unicode-data.nix
+++ b/pkgs/unicode-data.nix
@@ -1,4 +1,10 @@
-{ mkDerivation, base, deepseq, hspec, hspec-discover, lib, tasty
+{ mkDerivation
+, base
+, deepseq
+, hspec
+, hspec-discover
+, lib
+, tasty
 , tasty-bench
 }:
 mkDerivation {
@@ -18,4 +24,4 @@ mkDerivation {
   homepage = "http://github.com/composewell/unicode-data";
   description = "Access Unicode Character Database (UCD)";
   license = lib.licenses.asl20;
-}
\ No newline at end of file
+}
diff --git a/pkgs/unicode-transforms.nix b/pkgs/unicode-transforms.nix
index 12d767ca3cb7d93de8ebbe46d777cc812e63281c..83ea2637f94951ea3c8636e724d98a9bdb94fdd7 100644
--- a/pkgs/unicode-transforms.nix
+++ b/pkgs/unicode-transforms.nix
@@ -1,5 +1,17 @@
-{ mkDerivation, base, bytestring, deepseq, filepath, ghc-prim
-, hspec, lib, path, path-io, QuickCheck, split, tasty-bench, text
+{ mkDerivation
+, base
+, bytestring
+, deepseq
+, filepath
+, ghc-prim
+, hspec
+, lib
+, path
+, path-io
+, QuickCheck
+, split
+, tasty-bench
+, text
 , unicode-data
 }:
 mkDerivation {
@@ -11,13 +23,30 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    base bytestring ghc-prim text unicode-data
+    base
+    bytestring
+    ghc-prim
+    text
+    unicode-data
   ];
   testHaskellDepends = [
-    base bytestring deepseq hspec QuickCheck split text unicode-data
+    base
+    bytestring
+    deepseq
+    hspec
+    QuickCheck
+    split
+    text
+    unicode-data
   ];
   benchmarkHaskellDepends = [
-    base deepseq filepath path path-io tasty-bench text
+    base
+    deepseq
+    filepath
+    path
+    path-io
+    tasty-bench
+    text
   ];
   doHaddock = false;
   jailbreak = true;
@@ -26,4 +55,4 @@ mkDerivation {
   homepage = "http://github.com/composewell/unicode-transforms";
   description = "Unicode normalization";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/unordered-containers.nix b/pkgs/unordered-containers.nix
index 100a625f01b70f53032c9c668ff8a958dabbae91..dfb2eefbdb8ef4894ba11ae040f396395454385b 100644
--- a/pkgs/unordered-containers.nix
+++ b/pkgs/unordered-containers.nix
@@ -1,6 +1,21 @@
-{ mkDerivation, base, bytestring, ChasingBottoms, containers
-, deepseq, hashable, hashmap, HUnit, lib, mtl, nothunks, QuickCheck
-, random, tasty, tasty-bench, tasty-hunit, tasty-quickcheck
+{ mkDerivation
+, base
+, bytestring
+, ChasingBottoms
+, containers
+, deepseq
+, hashable
+, hashmap
+, HUnit
+, lib
+, mtl
+, nothunks
+, QuickCheck
+, random
+, tasty
+, tasty-bench
+, tasty-hunit
+, tasty-quickcheck
 , template-haskell
 }:
 mkDerivation {
@@ -11,11 +26,27 @@ mkDerivation {
   editedCabalFile = "0fcax3apnpxxy9maymclr6s2b4c28d3pkl3plbg0lv1mn0mh84fv";
   libraryHaskellDepends = [ base deepseq hashable template-haskell ];
   testHaskellDepends = [
-    base ChasingBottoms containers hashable HUnit nothunks QuickCheck
-    random tasty tasty-hunit tasty-quickcheck
+    base
+    ChasingBottoms
+    containers
+    hashable
+    HUnit
+    nothunks
+    QuickCheck
+    random
+    tasty
+    tasty-hunit
+    tasty-quickcheck
   ];
   benchmarkHaskellDepends = [
-    base bytestring containers deepseq hashable hashmap mtl random
+    base
+    bytestring
+    containers
+    deepseq
+    hashable
+    hashmap
+    mtl
+    random
     tasty-bench
   ];
   doHaddock = false;
@@ -25,4 +56,4 @@ mkDerivation {
   homepage = "https://github.com/haskell-unordered-containers/unordered-containers";
   description = "Efficient hashing-based container types";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/vault.nix b/pkgs/vault.nix
index ac37ec00b04cd12d83d3fa4c9da4acab46e0cde4..34ae89743a1ff476ec7e6e13216e949a08035e7f 100644
--- a/pkgs/vault.nix
+++ b/pkgs/vault.nix
@@ -1,4 +1,8 @@
-{ mkDerivation, base, containers, hashable, lib
+{ mkDerivation
+, base
+, containers
+, hashable
+, lib
 , unordered-containers
 }:
 mkDerivation {
@@ -8,7 +12,10 @@ mkDerivation {
   revision = "2";
   editedCabalFile = "1bjwv3nv8jfhrdxa5kn3gvgxmyalpq7592bvyl7bpvcc7bbkfkf3";
   libraryHaskellDepends = [
-    base containers hashable unordered-containers
+    base
+    containers
+    hashable
+    unordered-containers
   ];
   doHaddock = false;
   jailbreak = true;
@@ -17,4 +24,4 @@ mkDerivation {
   homepage = "https://github.com/HeinrichApfelmus/vault";
   description = "a persistent store for values of arbitrary types";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/vector-algorithms.nix b/pkgs/vector-algorithms.nix
index 92decc1d2283fbca40259af4db795e7b8e60da1c..5b72fa9085063f77bc7df97eea49786cbeb6096b 100644
--- a/pkgs/vector-algorithms.nix
+++ b/pkgs/vector-algorithms.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, base, bitvec, bytestring, containers, lib
-, mwc-random, primitive, QuickCheck, vector
+{ mkDerivation
+, base
+, bitvec
+, bytestring
+, containers
+, lib
+, mwc-random
+, primitive
+, QuickCheck
+, vector
 }:
 mkDerivation {
   pname = "vector-algorithms";
@@ -8,10 +16,18 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "1bma0m4g7770y4xnqsinspqkgf4swpdwddfbcby81szjxd8mik1l";
   libraryHaskellDepends = [
-    base bitvec bytestring primitive vector
+    base
+    bitvec
+    bytestring
+    primitive
+    vector
   ];
   testHaskellDepends = [
-    base bytestring containers QuickCheck vector
+    base
+    bytestring
+    containers
+    QuickCheck
+    vector
   ];
   benchmarkHaskellDepends = [ base mwc-random vector ];
   doHaddock = false;
@@ -21,4 +37,4 @@ mkDerivation {
   homepage = "https://github.com/erikd/vector-algorithms/";
   description = "Efficient algorithms for vector arrays";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/vector.nix b/pkgs/vector.nix
index a0f0aa26b042d380e6f96808e0aeeb712e5d4bf7..d274c6c67a1fe7665798a3470f5fcd4dcad19126 100644
--- a/pkgs/vector.nix
+++ b/pkgs/vector.nix
@@ -1,7 +1,21 @@
-{ mkDerivation, base, base-orphans, deepseq, doctest, HUnit, lib
-, primitive, QuickCheck, random, tasty, tasty-bench, tasty-hunit
-, tasty-inspection-testing, tasty-quickcheck, template-haskell
-, transformers, vector-stream
+{ mkDerivation
+, base
+, base-orphans
+, deepseq
+, doctest
+, HUnit
+, lib
+, primitive
+, QuickCheck
+, random
+, tasty
+, tasty-bench
+, tasty-hunit
+, tasty-inspection-testing
+, tasty-quickcheck
+, template-haskell
+, transformers
+, vector-stream
 }:
 mkDerivation {
   pname = "vector";
@@ -11,9 +25,19 @@ mkDerivation {
   editedCabalFile = "12cwdaqsy9dv7j7cwq6r6kdyfxqiya8khm6ccaabjhhpa2aqwljl";
   libraryHaskellDepends = [ base deepseq primitive vector-stream ];
   testHaskellDepends = [
-    base base-orphans doctest HUnit primitive QuickCheck random tasty
-    tasty-hunit tasty-inspection-testing tasty-quickcheck
-    template-haskell transformers
+    base
+    base-orphans
+    doctest
+    HUnit
+    primitive
+    QuickCheck
+    random
+    tasty
+    tasty-hunit
+    tasty-inspection-testing
+    tasty-quickcheck
+    template-haskell
+    transformers
   ];
   benchmarkHaskellDepends = [ base random tasty tasty-bench ];
   doHaddock = false;
@@ -23,4 +47,4 @@ mkDerivation {
   homepage = "https://github.com/haskell/vector";
   description = "Efficient Arrays";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/vinyl.nix b/pkgs/vinyl.nix
index 7aaea5b383efbaf601af021301fcb8747b04bf95..48556f36933a8fe9d5a09b1bfa66aaa6b257938a 100644
--- a/pkgs/vinyl.nix
+++ b/pkgs/vinyl.nix
@@ -1,7 +1,24 @@
-{ mkDerivation, aeson, array, base, criterion, deepseq, ghc-prim
-, hspec, lens, lens-aeson, lib, linear, microlens, mtl, mwc-random
-, primitive, should-not-typecheck, tagged, text
-, unordered-containers, vector
+{ mkDerivation
+, aeson
+, array
+, base
+, criterion
+, deepseq
+, ghc-prim
+, hspec
+, lens
+, lens-aeson
+, lib
+, linear
+, microlens
+, mtl
+, mwc-random
+, primitive
+, should-not-typecheck
+, tagged
+, text
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "vinyl";
@@ -9,11 +26,27 @@ mkDerivation {
   sha256 = "e6789cbf9d3db493065cc85251e1a4596e4ab561c857d2757ae2593dd53ce6d2";
   libraryHaskellDepends = [ array base deepseq ghc-prim ];
   testHaskellDepends = [
-    aeson base hspec lens lens-aeson microlens mtl should-not-typecheck
-    text unordered-containers vector
+    aeson
+    base
+    hspec
+    lens
+    lens-aeson
+    microlens
+    mtl
+    should-not-typecheck
+    text
+    unordered-containers
+    vector
   ];
   benchmarkHaskellDepends = [
-    base criterion linear microlens mwc-random primitive tagged vector
+    base
+    criterion
+    linear
+    microlens
+    mwc-random
+    primitive
+    tagged
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -21,4 +54,4 @@ mkDerivation {
   hyperlinkSource = false;
   description = "Extensible Records";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/vty.nix b/pkgs/vty.nix
index bf2699fbb6b99ba2033e3f6f0e108fbd250e0c77..4192d8003985664acd519307c4d919b2ce71690e 100644
--- a/pkgs/vty.nix
+++ b/pkgs/vty.nix
@@ -1,10 +1,38 @@
-{ mkDerivation, ansi-terminal, base, binary, blaze-builder
-, bytestring, Cabal, containers, deepseq, directory, filepath
-, hashable, HUnit, lib, microlens, microlens-mtl, microlens-th, mtl
-, parallel, parsec, QuickCheck, quickcheck-assertions, random
-, smallcheck, stm, string-qq, terminfo, test-framework
-, test-framework-hunit, test-framework-smallcheck, text
-, transformers, unix, utf8-string, vector
+{ mkDerivation
+, ansi-terminal
+, base
+, binary
+, blaze-builder
+, bytestring
+, Cabal
+, containers
+, deepseq
+, directory
+, filepath
+, hashable
+, HUnit
+, lib
+, microlens
+, microlens-mtl
+, microlens-th
+, mtl
+, parallel
+, parsec
+, QuickCheck
+, quickcheck-assertions
+, random
+, smallcheck
+, stm
+, string-qq
+, terminfo
+, test-framework
+, test-framework-hunit
+, test-framework-smallcheck
+, text
+, transformers
+, unix
+, utf8-string
+, vector
 }:
 mkDerivation {
   pname = "vty";
@@ -13,20 +41,64 @@ mkDerivation {
   isLibrary = true;
   isExecutable = true;
   libraryHaskellDepends = [
-    ansi-terminal base binary blaze-builder bytestring containers
-    deepseq directory filepath hashable microlens microlens-mtl
-    microlens-th mtl parallel parsec stm terminfo text transformers
-    unix utf8-string vector
+    ansi-terminal
+    base
+    binary
+    blaze-builder
+    bytestring
+    containers
+    deepseq
+    directory
+    filepath
+    hashable
+    microlens
+    microlens-mtl
+    microlens-th
+    mtl
+    parallel
+    parsec
+    stm
+    terminfo
+    text
+    transformers
+    unix
+    utf8-string
+    vector
   ];
   executableHaskellDepends = [
-    base containers directory filepath microlens microlens-mtl mtl
+    base
+    containers
+    directory
+    filepath
+    microlens
+    microlens-mtl
+    mtl
   ];
   testHaskellDepends = [
-    base blaze-builder bytestring Cabal containers deepseq HUnit
-    microlens microlens-mtl mtl QuickCheck quickcheck-assertions random
-    smallcheck stm string-qq terminfo test-framework
-    test-framework-hunit test-framework-smallcheck text unix
-    utf8-string vector
+    base
+    blaze-builder
+    bytestring
+    Cabal
+    containers
+    deepseq
+    HUnit
+    microlens
+    microlens-mtl
+    mtl
+    QuickCheck
+    quickcheck-assertions
+    random
+    smallcheck
+    stm
+    string-qq
+    terminfo
+    test-framework
+    test-framework-hunit
+    test-framework-smallcheck
+    text
+    unix
+    utf8-string
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -35,4 +107,4 @@ mkDerivation {
   homepage = "https://github.com/jtdaugherty/vty";
   description = "A simple terminal UI library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/wai-middleware-static.nix b/pkgs/wai-middleware-static.nix
index de1b5f85c3a5d7f3089e5388f3ee15a35e37046a..1e8a3bd78236e5a62f11330b057b06e629e06e59 100644
--- a/pkgs/wai-middleware-static.nix
+++ b/pkgs/wai-middleware-static.nix
@@ -1,8 +1,27 @@
-{ mkDerivation, base, base16-bytestring, bytestring, containers
-, cryptohash-sha1, directory, expiring-cache-map, filepath, hspec
-, hspec-discover, hspec-expectations-lifted, hspec-wai, http-types
-, lib, mime-types, mockery, old-locale, scotty, semigroups, text
-, time, wai, wai-extra
+{ mkDerivation
+, base
+, base16-bytestring
+, bytestring
+, containers
+, cryptohash-sha1
+, directory
+, expiring-cache-map
+, filepath
+, hspec
+, hspec-discover
+, hspec-expectations-lifted
+, hspec-wai
+, http-types
+, lib
+, mime-types
+, mockery
+, old-locale
+, scotty
+, semigroups
+, text
+, time
+, wai
+, wai-extra
 }:
 mkDerivation {
   pname = "wai-middleware-static";
@@ -11,13 +30,31 @@ mkDerivation {
   revision = "1";
   editedCabalFile = "1zran8wpwizrwdw23a5qckmiplyk6xf2z8x4his0ipfy2zzl5ql6";
   libraryHaskellDepends = [
-    base base16-bytestring bytestring containers cryptohash-sha1
-    directory expiring-cache-map filepath http-types mime-types
-    old-locale semigroups text time wai
+    base
+    base16-bytestring
+    bytestring
+    containers
+    cryptohash-sha1
+    directory
+    expiring-cache-map
+    filepath
+    http-types
+    mime-types
+    old-locale
+    semigroups
+    text
+    time
+    wai
   ];
   testHaskellDepends = [
-    base hspec hspec-expectations-lifted hspec-wai http-types mockery
-    scotty wai-extra
+    base
+    hspec
+    hspec-expectations-lifted
+    hspec-wai
+    http-types
+    mockery
+    scotty
+    wai-extra
   ];
   testToolDepends = [ hspec-discover ];
   doHaddock = false;
@@ -27,4 +64,4 @@ mkDerivation {
   homepage = "https://github.com/scotty-web/wai-middleware-static";
   description = "WAI middleware that serves requests to static files";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/warp-tls.nix b/pkgs/warp-tls.nix
index 09b52eb25a595ba0812e8a9833f9127a147aef67..6193f03c92307845de022c5f527f0cb20849e88d 100644
--- a/pkgs/warp-tls.nix
+++ b/pkgs/warp-tls.nix
@@ -1,14 +1,33 @@
-{ mkDerivation, base, bytestring, cryptonite, data-default-class
-, lib, network, streaming-commons, tls, tls-session-manager
-, unliftio, wai, warp
+{ mkDerivation
+, base
+, bytestring
+, cryptonite
+, data-default-class
+, lib
+, network
+, streaming-commons
+, tls
+, tls-session-manager
+, unliftio
+, wai
+, warp
 }:
 mkDerivation {
   pname = "warp-tls";
   version = "3.3.3";
   sha256 = "5c44be7a903b863b330d1b9c152100ed7d1709f972e25401018bab407d3f69a0";
   libraryHaskellDepends = [
-    base bytestring cryptonite data-default-class network
-    streaming-commons tls tls-session-manager unliftio wai warp
+    base
+    bytestring
+    cryptonite
+    data-default-class
+    network
+    streaming-commons
+    tls
+    tls-session-manager
+    unliftio
+    wai
+    warp
   ];
   doHaddock = false;
   jailbreak = true;
@@ -17,4 +36,4 @@ mkDerivation {
   homepage = "http://github.com/yesodweb/wai";
   description = "HTTP over TLS support for Warp via the TLS package";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/warp.nix b/pkgs/warp.nix
index 8e65ace181849ec865050bd867b09a27c014e3b2..bd6121e30ebd7754d64fa804d2a08532924ecbc6 100644
--- a/pkgs/warp.nix
+++ b/pkgs/warp.nix
@@ -1,9 +1,40 @@
-{ mkDerivation, array, async, auto-update, base, bsb-http-chunked
-, bytestring, case-insensitive, containers, directory, gauge
-, ghc-prim, hashable, hspec, hspec-discover, http-client, http-date
-, http-types, http2, HUnit, iproute, lib, network, process
-, QuickCheck, simple-sendfile, stm, streaming-commons, text, time
-, time-manager, unix, unix-compat, unliftio, vault, wai, word8
+{ mkDerivation
+, array
+, async
+, auto-update
+, base
+, bsb-http-chunked
+, bytestring
+, case-insensitive
+, containers
+, directory
+, gauge
+, ghc-prim
+, hashable
+, hspec
+, hspec-discover
+, http-client
+, http-date
+, http-types
+, http2
+, HUnit
+, iproute
+, lib
+, network
+, process
+, QuickCheck
+, simple-sendfile
+, stm
+, streaming-commons
+, text
+, time
+, time-manager
+, unix
+, unix-compat
+, unliftio
+, vault
+, wai
+, word8
 , x509
 }:
 mkDerivation {
@@ -11,22 +42,85 @@ mkDerivation {
   version = "3.3.22";
   sha256 = "ea26386fa12f86bc8d04446cc551ccc5c918debe4ad947f6c6bf514da3f04f3e";
   libraryHaskellDepends = [
-    array auto-update base bsb-http-chunked bytestring case-insensitive
-    containers ghc-prim hashable http-date http-types http2 iproute
-    network simple-sendfile stm streaming-commons text time-manager
-    unix unix-compat unliftio vault wai word8 x509
+    array
+    auto-update
+    base
+    bsb-http-chunked
+    bytestring
+    case-insensitive
+    containers
+    ghc-prim
+    hashable
+    http-date
+    http-types
+    http2
+    iproute
+    network
+    simple-sendfile
+    stm
+    streaming-commons
+    text
+    time-manager
+    unix
+    unix-compat
+    unliftio
+    vault
+    wai
+    word8
+    x509
   ];
   testHaskellDepends = [
-    array async auto-update base bsb-http-chunked bytestring
-    case-insensitive containers directory ghc-prim hashable hspec
-    http-client http-date http-types http2 HUnit iproute network
-    process QuickCheck simple-sendfile stm streaming-commons text time
-    time-manager unix unix-compat unliftio vault wai word8 x509
+    array
+    async
+    auto-update
+    base
+    bsb-http-chunked
+    bytestring
+    case-insensitive
+    containers
+    directory
+    ghc-prim
+    hashable
+    hspec
+    http-client
+    http-date
+    http-types
+    http2
+    HUnit
+    iproute
+    network
+    process
+    QuickCheck
+    simple-sendfile
+    stm
+    streaming-commons
+    text
+    time
+    time-manager
+    unix
+    unix-compat
+    unliftio
+    vault
+    wai
+    word8
+    x509
   ];
   testToolDepends = [ hspec-discover ];
   benchmarkHaskellDepends = [
-    auto-update base bytestring containers gauge hashable http-date
-    http-types network time-manager unix unix-compat unliftio x509
+    auto-update
+    base
+    bytestring
+    containers
+    gauge
+    hashable
+    http-date
+    http-types
+    network
+    time-manager
+    unix
+    unix-compat
+    unliftio
+    x509
   ];
   doHaddock = false;
   jailbreak = true;
@@ -35,4 +129,4 @@ mkDerivation {
   homepage = "http://github.com/yesodweb/wai";
   description = "A fast, light-weight web server for WAI applications";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}
diff --git a/pkgs/with-utf8.nix b/pkgs/with-utf8.nix
index 4af52edab826ac8533e7484aee43470192463e2c..4df52c1bb70301cd3ca09e692847f22df0e3cae2 100644
--- a/pkgs/with-utf8.nix
+++ b/pkgs/with-utf8.nix
@@ -1,6 +1,21 @@
-{ mkDerivation, base, deepseq, directory, filepath, hedgehog, HUnit
-, lib, process, safe-exceptions, tasty, tasty-discover
-, tasty-hedgehog, tasty-hunit, temporary, text, th-env, unix
+{ mkDerivation
+, base
+, deepseq
+, directory
+, filepath
+, hedgehog
+, HUnit
+, lib
+, process
+, safe-exceptions
+, tasty
+, tasty-discover
+, tasty-hedgehog
+, tasty-hunit
+, temporary
+, text
+, th-env
+, unix
 }:
 mkDerivation {
   pname = "with-utf8";
@@ -10,11 +25,26 @@ mkDerivation {
   isExecutable = true;
   libraryHaskellDepends = [ base safe-exceptions text ];
   executableHaskellDepends = [
-    base directory filepath process safe-exceptions text th-env
+    base
+    directory
+    filepath
+    process
+    safe-exceptions
+    text
+    th-env
   ];
   testHaskellDepends = [
-    base deepseq hedgehog HUnit safe-exceptions tasty tasty-hedgehog
-    tasty-hunit temporary text unix
+    base
+    deepseq
+    hedgehog
+    HUnit
+    safe-exceptions
+    tasty
+    tasty-hedgehog
+    tasty-hunit
+    temporary
+    text
+    unix
   ];
   testToolDepends = [ tasty-discover ];
   doHaddock = false;
@@ -25,4 +55,4 @@ mkDerivation {
   description = "Get your IO right on the first try";
   license = lib.licenses.mpl20;
   mainProgram = "utf8-troubleshoot";
-}
\ No newline at end of file
+}
diff --git a/pkgs/witherable.nix b/pkgs/witherable.nix
index 01d38eb572d9ab4f59e9bf7465369b59aa9c6396..599c7105801048092081ae5c25ce850033024337 100644
--- a/pkgs/witherable.nix
+++ b/pkgs/witherable.nix
@@ -1,7 +1,18 @@
-{ mkDerivation, base, base-orphans, containers, hashable
-, indexed-traversable, indexed-traversable-instances, lib
-, QuickCheck, quickcheck-instances, tasty, tasty-quickcheck
-, transformers, unordered-containers, vector
+{ mkDerivation
+, base
+, base-orphans
+, containers
+, hashable
+, indexed-traversable
+, indexed-traversable-instances
+, lib
+, QuickCheck
+, quickcheck-instances
+, tasty
+, tasty-quickcheck
+, transformers
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "witherable";
@@ -10,13 +21,27 @@ mkDerivation {
   revision = "3";
   editedCabalFile = "1f2bvl41by904lnr0dk6qgasqwadq2w48l7fj51bp2h8bqbkdjyc";
   libraryHaskellDepends = [
-    base base-orphans containers hashable indexed-traversable
-    indexed-traversable-instances transformers unordered-containers
+    base
+    base-orphans
+    containers
+    hashable
+    indexed-traversable
+    indexed-traversable-instances
+    transformers
+    unordered-containers
     vector
   ];
   testHaskellDepends = [
-    base containers hashable QuickCheck quickcheck-instances tasty
-    tasty-quickcheck transformers unordered-containers vector
+    base
+    containers
+    hashable
+    QuickCheck
+    quickcheck-instances
+    tasty
+    tasty-quickcheck
+    transformers
+    unordered-containers
+    vector
   ];
   doHaddock = false;
   jailbreak = true;
@@ -25,4 +50,4 @@ mkDerivation {
   homepage = "https://github.com/fumieval/witherable";
   description = "filterable traversable";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+}
diff --git a/pkgs/xml-conduit.nix b/pkgs/xml-conduit.nix
index 6a6b0d37591ef27f771aa194cacdbff5e9e04539..2d806feb8d66dd41d7729a322ee21cc8e0f0e6e8 100644
--- a/pkgs/xml-conduit.nix
+++ b/pkgs/xml-conduit.nix
@@ -1,7 +1,24 @@
-{ mkDerivation, attoparsec, base, blaze-html, blaze-markup
-, bytestring, Cabal, cabal-doctest, conduit, conduit-extra
-, containers, data-default-class, deepseq, doctest, hspec, HUnit
-, lib, resourcet, text, transformers, xml-types
+{ mkDerivation
+, attoparsec
+, base
+, blaze-html
+, blaze-markup
+, bytestring
+, Cabal
+, cabal-doctest
+, conduit
+, conduit-extra
+, containers
+, data-default-class
+, deepseq
+, doctest
+, hspec
+, HUnit
+, lib
+, resourcet
+, text
+, transformers
+, xml-types
 }:
 mkDerivation {
   pname = "xml-conduit";
@@ -11,13 +28,35 @@ mkDerivation {
   editedCabalFile = "0x4is0956lfpxnxf2hqv5yvl1v8r1d41h3a22qqkvbqi13xz2hzv";
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
-    attoparsec base blaze-html blaze-markup bytestring conduit
-    conduit-extra containers data-default-class deepseq resourcet text
-    transformers xml-types
+    attoparsec
+    base
+    blaze-html
+    blaze-markup
+    bytestring
+    conduit
+    conduit-extra
+    containers
+    data-default-class
+    deepseq
+    resourcet
+    text
+    transformers
+    xml-types
   ];
   testHaskellDepends = [
-    base blaze-markup bytestring conduit conduit-extra containers
-    doctest hspec HUnit resourcet text transformers xml-types
+    base
+    blaze-markup
+    bytestring
+    conduit
+    conduit-extra
+    containers
+    doctest
+    hspec
+    HUnit
+    resourcet
+    text
+    transformers
+    xml-types
   ];
   doHaddock = false;
   jailbreak = true;
@@ -26,4 +65,4 @@ mkDerivation {
   homepage = "http://github.com/snoyberg/xml";
   description = "Pure-Haskell utilities for dealing with XML with the conduit package";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+}