@@ -2,8 +2,8 @@
22#
33# for hygenic reasons we'll use haskell-nix as a prefix.
44# Using haskell.nix in nix is awkward as I needs to be quoted.
5−self: super: {
6− haskell-nix = with self.haskell-nix; {
5+final: prev: {
6+ haskell-nix = with final.haskell-nix; {
77
88 # Default modules, these will always be included.
99 # They are here to be overridden/added to by other
@@ -13,7 +13,7 @@ self: super: {
1313 # We provide a `callPackage` function to consumers for
1414 # convenience. We will however refrain from using it
1515 # here and be explicit about imports and dependencies.
16− callPackage = super.lib.callPackageWith (self // self.haskell-nix);
16+ callPackage = prev.lib.callPackageWith (final // final.haskell-nix);
1717
1818 # You can provide different pins for hackage.nix and stackage.nix if required.
1919 # It's also possible to override these sources with NIX_PATH.
@@ -32,7 +32,7 @@ self: super: {
3232 fetchExternal = import ../lib/fetch-external.nix;
3333
3434 # Functions for cleaning Haskell source directories.
35− inherit (import ../lib/clean-source-haskell.nix { inherit (self) lib; })
35+ inherit (import ../lib/clean-source-haskell.nix { inherit (final) lib; })
3636 haskellSourceFilter
3737 cleanSourceHaskell;
3838
@@ -59,8 +59,8 @@ self: super: {
5959
6060 # Utility functions for working with the component builder.
6161 haskellLib = let hl = import ../lib {
62− inherit (self) stdenv lib runCommand recurseIntoAttrs srcOnly;
63− inherit (self.buildPackages) git;
62+ inherit (final) stdenv lib runCommand recurseIntoAttrs srcOnly;
63+ inherit (final.buildPackages) git;
6464 haskellLib = hl;
6565 }; in hl;
6666
@@ -80,7 +80,7 @@ self: super: {
8080 import ../package-set.nix {
8181 inherit (args) pkg-def pkg-def-extras;
8282 modules = defaultModules ++ modules;
83− pkgs = self;
83+ pkgs = final;
8484 hackage = hackageAll;
8585 };
8686
@@ -89,10 +89,10 @@ self: super: {
8989 # info. Instead we can add ghc-boot-packages to `pkg-def-extras`.
9090 excludeBootPackages = pkg-def: hackage:
9191 let original = pkg-def hackage;
92− bootPkgNames = self.lib.attrNames
93− self.ghc-boot-packages.${(pkg-def hackage).compiler.nix-name};
92+ bootPkgNames = final.lib.attrNames
93+ final.ghc-boot-packages.${(pkg-def hackage).compiler.nix-name};
9494 in original // {
95− packages = self.lib.filterAttrs (n: _: self.lib.all (b: n != b) bootPkgNames)
95+ packages = final.lib.filterAttrs (n: _: final.lib.all (b: n != b) bootPkgNames)
9696 original.packages;
9797 };
9898
@@ -119,7 +119,7 @@ self: super: {
119119 in mkPkgSet {
120120 pkg-def = excludeBootPackages pkg-def;
121121 pkg-def-extras = [ stack-pkgs.extras
122− self.ghc-boot-packages.${compiler.nix-name}
122+ final.ghc-boot-packages.${compiler.nix-name}
123123 ]
124124 ++ pkg-def-extras;
125125 # set doExactConfig = true. The stackage set should be consistent
@@ -145,7 +145,7 @@ self: super: {
145145 in mkPkgSet {
146146 inherit pkg-def;
147147 pkg-def-extras = [ plan-pkgs.extras
148− self.ghc-boot-packages.${compiler.nix-name}
148+ final.ghc-boot-packages.${compiler.nix-name}
149149 ]
150150 ++ pkg-def-extras;
151151 # set doExactConfig = true, as we trust cabals resolution for
@@ -157,7 +157,7 @@ self: super: {
157157 };
158158
159159 # Package sets for all stackage snapshots.
160− snapshots = import ../snapshots.nix { inherit (self) lib ghc-boot-packages; inherit mkPkgSet stackage excludeBootPackages; };
160+ snapshots = import ../snapshots.nix { inherit (final) lib ghc-boot-packages; inherit mkPkgSet stackage excludeBootPackages; };
161161 # Pick a recent LTS snapshot to be our "default" package set.
162162 haskellPackages = snapshots."lts-14.13";
163163
@@ -165,26 +165,26 @@ self: super: {
165165 # files. This version of nix-tools may be cross compiled.
166166 # We probably never want to actually cross compile nix-tools on
167167 # it's own.
168− nix-tools-cross-compiled = self.lib.makeOverridable (import ../nix-tools) {
169− inherit (self) pkgs lib symlinkJoin makeWrapper
168+ nix-tools-cross-compiled = final.lib.makeOverridable (import ../nix-tools) {
169+ inherit (final) pkgs lib symlinkJoin makeWrapper
170170 git nix nix-prefetch-git;
171− inherit (self.haskell-nix) fetchExternal cleanSourceHaskell mkCabalProjectPkgSet;
171+ inherit (final.haskell-nix) fetchExternal cleanSourceHaskell mkCabalProjectPkgSet;
172172 hpack = null; # nix-tools does not use hpack project files
173173 };
174174 # While `nix-tools-cross-compiled` may be cross compiled,
175175 # getting it from `buildPackages` we should get
176176 # nix-tools suitable for running on the build system.
177− nix-tools = self.buildPackages.haskell-nix.nix-tools-cross-compiled;
177+ nix-tools = final.buildPackages.haskell-nix.nix-tools-cross-compiled;
178178 # TODO perhaps there is a cleaner way to get a suitable nix-tools.
179179
180180 # Produce a fixed output derivation from a moving target (hackage index tarball)
181181 # Takes desired index-state and sha256 and produces a set { name, index }, where
182182 # index points to "01-index.tar.gz" file downloaded from hackage.haskell.org.
183− hackageTarball = { index-state, sha256, nix-tools ? self.haskell-nix.nix-tools, ... }:
183+ hackageTarball = { index-state, sha256, nix-tools ? final.haskell-nix.nix-tools, ... }:
184184 assert sha256 != null;
185185 let at = builtins.replaceStrings [":"] [""] index-state; in
186186 { name = "hackage.haskell.org-at-${at}";
187− index = self.fetchurl {
187+ index = final.fetchurl {
188188 name = "01-index.tar.gz-at-${at}";
189189 url = "https://hackage.haskell.org/01-index.tar.gz";
190190 downloadToTemp = true;
@@ -196,20 +196,20 @@ self: super: {
196196 };
197197
198198 # Creates Cabal local repository from { name, index } set.
199− mkLocalHackageRepo = import ../mk-local-hackage-repo self;
199+ mkLocalHackageRepo = import ../mk-local-hackage-repo final;
200200
201201 dotCabal = { index-state, sha256, cabal-install, extra-hackage-tarballs ? [], ... }@args:
202202 let
203203 allTarballs = [ (hackageTarball args) ] ++ extra-hackage-tarballs;
204− allNames = self.lib.concatMapStringsSep "-" (tarball: tarball.name) allTarballs;
204+ allNames = final.lib.concatMapStringsSep "-" (tarball: tarball.name) allTarballs;
205205 # Main Hackage index-state is embedded in its name and thus will propagate to
206206 # dotCabalName anyway.
207207 dotCabalName = "dot-cabal-" + allNames;
208208 in
209− self.runCommand dotCabalName { nativeBuildInputs = [ cabal-install ]; } ''
209+ final.runCommand dotCabalName { nativeBuildInputs = [ cabal-install ]; } ''
210210 mkdir -p $out/.cabal
211211 cat <<EOF > $out/.cabal/config
212− ${self.lib.concatStrings (
212+ ${final.lib.concatStrings (
213213 map (tarball:
214214 ''
215215 repository ${tarball.name}
@@ -224,11 +224,11 @@ self: super: {
224224
225225 # All repositories must be mkdir'ed before calling new-update on any repo,
226226 # otherwise it fails.
227− ${self.lib.concatStrings (map ({ name, ... }: ''
227+ ${final.lib.concatStrings (map ({ name, ... }: ''
228228 mkdir -p $out/.cabal/packages/${name}
229229 '') allTarballs)}
230230
231− ${self.lib.concatStrings (map ({ name, ... }: ''
231+ ${final.lib.concatStrings (map ({ name, ... }: ''
232232 HOME=$out cabal new-update ${name}
233233 '') allTarballs)}
234234 '';
@@ -245,31 +245,31 @@ self: super: {
245245
246246 # Helps materialize the output of derivations
247247 materialize = import ../lib/materialize.nix {
248− inherit (self.buildPackages) nix;
249− inherit (self.haskell-nix) checkMaterialization;
250− pkgs = self.buildPackages.pkgs;
251− inherit (self.buildPackages.pkgs) runCommand;
248+ inherit (final.buildPackages) nix;
249+ inherit (final.haskell-nix) checkMaterialization;
250+ pkgs = final.buildPackages.pkgs;
251+ inherit (final.buildPackages.pkgs) runCommand;
252252 };
253253
254254 update-index-state-hashes = import ../scripts/update-index-state-hashes.nix {
255− inherit (self.haskell-nix) indexStateHashesPath nix-tools;
256− inherit (self) coreutils nix writeShellScriptBin stdenv curl;
255+ inherit (final.haskell-nix) indexStateHashesPath nix-tools;
256+ inherit (final) coreutils nix writeShellScriptBin stdenv curl;
257257 };
258258
259259 # Function to call stackToNix
260260 callStackToNix = import ../lib/call-stack-to-nix.nix {
261− pkgs = self.buildPackages.pkgs;
262− inherit (self.buildPackages.pkgs) runCommand;
263− inherit (self.buildPackages.haskell-nix) nix-tools mkCacheFile materialize;
261+ pkgs = final.buildPackages.pkgs;
262+ inherit (final.buildPackages.pkgs) runCommand;
263+ inherit (final.buildPackages.haskell-nix) nix-tools mkCacheFile materialize;
264264 };
265265
266266 # given a source location call `cabal-to-nix` (from nix-tools) on it
267267 # to produce the nix representation of it.
268268 callCabalToNix = { name, src, cabal-file ? "${name}.cabal" }:
269− self.buildPackages.pkgs.runCommand "${name}.nix" {
270− nativeBuildInputs = [ self.buildPackages.haskell-nix.nix-tools ];
269+ final.buildPackages.pkgs.runCommand "${name}.nix" {
270+ nativeBuildInputs = [ final.buildPackages.haskell-nix.nix-tools ];
271271
272− LOCALE_ARCHIVE = self.lib.optionalString (self.stdenv.buildPlatform.libc == "glibc") "${self.buildPackages.glibcLocales}/lib/locale/locale-archive";
272+ LOCALE_ARCHIVE = final.lib.optionalString (final.stdenv.buildPlatform.libc == "glibc") "${final.buildPackages.glibcLocales}/lib/locale/locale-archive";
273273 LANG = "en_US.UTF-8";
274274 LC_ALL = "en_US.UTF-8";
275275 } ''
@@ -297,7 +297,7 @@ self: super: {
297297 assert isNull sha256;
298298 builtins.fetchGit
299299 ({ inherit url rev; } //
300− self.buildPackages.lib.optionalAttrs (ref != null) { inherit ref; }
300+ final.buildPackages.lib.optionalAttrs (ref != null) { inherit ref; }
301301 )
302302 else
303303 # Non-private repos must have sha256 set.
@@ -305,7 +305,7 @@ self: super: {
305305 # pkgs.fetchgit doesn't have any way of fetching from a given
306306 # ref.
307307 assert isNull ref;
308− self.buildPackages.pkgs.fetchgit {
308+ final.buildPackages.pkgs.fetchgit {
309309 url = url;
310310 rev = rev;
311311 sha256 = sha256;
@@ -318,20 +318,20 @@ self: super: {
318318 nix-expr =
319319 if type == "cabal"
320320 then
321− self.buildPackages.haskell-nix.callCabalToNix {
321+ final.buildPackages.haskell-nix.callCabalToNix {
322322 src = repoWithSubdir;
323323 inherit name cabal-file;
324324 }
325325 else if type == "stack"
326326 then
327− (self.buildPackages.haskell-nix.callStackToNix {
327+ (final.buildPackages.haskell-nix.callStackToNix {
328328 src = repoWithSubdir;
329329 inherit name subdir;
330330 }).projectNix
331331 else
332332 throw "Unknown type '${type}` for a cache entry";
333333
334− sha256String = if isNull sha256 then self.buildPackages.lib.fakeSha256 else sha256;
334+ sha256String = if isNull sha256 then final.buildPackages.lib.fakeSha256 else sha256;
335335
336336 in {
337337 line = "${url} ${rev} ${subdir} ${sha256String} ${name}";
@@ -347,24 +347,24 @@ self: super: {
347347 # the results of `stack-to-nix` can be imported in restrected eval
348348 # mode.
349349 mkCacheFile = repos:
350− self.buildPackages.pkgs.runCommand "cache-file" {} ''
350+ final.buildPackages.pkgs.runCommand "cache-file" {} ''
351351 mkdir -p $out
352352 touch $out/.stack-to-nix.cache
353− ${self.lib.concatStrings (
354− self.lib.lists.zipListsWith (n: repo:
353+ ${final.lib.concatStrings (
354+ final.lib.lists.zipListsWith (n: repo:
355355 let l = mkCacheLine repo;
356356 in ''
357357 cp ${l.nix-expr} $out/.stack-to-nix.cache.${toString n}
358358 echo ${l.line} .stack-to-nix.cache.${toString n} >> $out/.stack-to-nix.cache
359359 '')
360− (self.lib.lists.range 0 ((builtins.length repos) - 1))
360+ (final.lib.lists.range 0 ((builtins.length repos) - 1))
361361 repos)
362362 }
363363 '';
364364
365365 genStackCache = import ../lib/stack-cache-generator.nix {
366− inherit (self.buildPackages) pkgs;
367− inherit (self.buildPackages.haskell-nix) haskellLib nix-tools;
366+ inherit (final.buildPackages) pkgs;
367+ inherit (final.buildPackages.haskell-nix) haskellLib nix-tools;
368368 };
369369
370370 mkCacheModule = cache:
@@ -391,11 +391,11 @@ self: super: {
391391 then
392392 builtins.fetchGit
393393 ({ inherit url rev; } //
394− self.buildPackages.lib.optionalAttrs (ref != null) { inherit ref; }
394+ final.buildPackages.lib.optionalAttrs (ref != null) { inherit ref; }
395395 )
396396 else
397− self.buildPackages.pkgs.fetchgit { inherit url rev sha256; };
398− } // self.buildPackages.lib.optionalAttrs (subdir != null) { postUnpack = "sourceRoot+=/${subdir}; echo source root reset to $sourceRoot"; };
397+ final.buildPackages.pkgs.fetchgit { inherit url rev sha256; };
398+ } // final.buildPackages.lib.optionalAttrs (subdir != null) { postUnpack = "sourceRoot+=/${subdir}; echo source root reset to $sourceRoot"; };
399399 };
400400
401401 cacheMap = builtins.map repoToAttr cache;
@@ -408,23 +408,23 @@ self: super: {
408408 # Resulting nix files are added to nix-plan subdirectory.
409409 callCabalProjectToNix = import ../lib/call-cabal-project-to-nix.nix {
410410 index-state-hashes = import indexStateHashesPath;
411− inherit (self.buildPackages.haskell-nix) dotCabal nix-tools haskellLib materialize;
412− pkgs = self.buildPackages.pkgs;
413− inherit (self.buildPackages.haskell-nix.haskellPackages.hpack.components.exes) hpack;
414− inherit (self.buildPackages.haskell-nix) cabal-install ghc;
415− inherit (self.buildPackages.pkgs) runCommand symlinkJoin cacert;
411+ inherit (final.buildPackages.haskell-nix) dotCabal nix-tools haskellLib materialize;
412+ pkgs = final.buildPackages.pkgs;
413+ inherit (final.buildPackages.haskell-nix.haskellPackages.hpack.components.exes) hpack;
414+ inherit (final.buildPackages.haskell-nix) cabal-install ghc;
415+ inherit (final.buildPackages.pkgs) runCommand symlinkJoin cacert;
416416 };
417417
418418 # Loads a plan and filters the package directories using cleanSourceWith
419419 importAndFilterProject = import ../lib/import-and-filter-project.nix {
420− inherit (self.buildPackages.haskell-nix) haskellLib;
421− pkgs = self.buildPackages.pkgs;
420+ inherit (final.buildPackages.haskell-nix) haskellLib;
421+ pkgs = final.buildPackages.pkgs;
422422 };
423423
424424 # References to the unpacked sources, for caching in a Hydra jobset.
425425 source-pins = import ../lib/make-source-pins.nix {
426− inherit (self) lib writeTextFile;
427− sources = [ hackageSrc stackageSrc self.path ];
426+ inherit (final) lib writeTextFile;
427+ sources = [ hackageSrc stackageSrc final.path ];
428428 };
429429
430430 # -- IFDs --
@@ -440,17 +440,17 @@ self: super: {
440440 { name
441441 , version
442442 , ... }@args:
443− let tarball = self.pkgs.fetchurl {
443+ let tarball = final.pkgs.fetchurl {
444444 url = "mirror://hackage/${name}-${version}.tar.gz";
445445 inherit (hackage.${name}.${version}) sha256; };
446− in let src = self.buildPackages.pkgs.runCommand "${name}-${version}-src" { } ''
446+ in let src = final.buildPackages.pkgs.runCommand "${name}-${version}-src" { } ''
447447 tmp=$(mktemp -d)
448448 cd $tmp
449449 tar xzf ${tarball}
450450 mv "${name}-${version}" $out
451451 '';
452452 in cabalProject' (
453− (self.haskell-nix.hackageQuirks { inherit name version; }) //
453+ (final.haskell-nix.hackageQuirks { inherit name version; }) //
454454 builtins.removeAttrs args [ "version" ] // { inherit src; });
455455
456456 # This function is like `cabalProject` but it makes the plan-nix available
@@ -463,7 +463,7 @@ self: super: {
463463 { plan-pkgs = plan.pkgs;
464464 pkg-def-extras = args.pkg-def-extras or [];
465465 modules = (args.modules or [])
466− ++ self.lib.optional (args ? ghc) { ghc.package = args.ghc; };
466+ ++ final.lib.optional (args ? ghc) { ghc.package = args.ghc; };
467467 extra-hackages = args.extra-hackages or [];
468468 };
469469 in { inherit (pkg-set.config) hsPkgs; inherit pkg-set; plan-nix = plan.nix; };
@@ -487,9 +487,9 @@ self: super: {
487487 in let pkg-set = mkStackPkgSet
488488 { stack-pkgs = stack.pkgs;
489489 pkg-def-extras = (args.pkg-def-extras or []);
490− modules = self.lib.singleton (mkCacheModule cache)
490+ modules = final.lib.singleton (mkCacheModule cache)
491491 ++ (args.modules or [])
492− ++ self.lib.optional (args ? ghc) { ghc.package = args.ghc; };
492+ ++ final.lib.optional (args ? ghc) { ghc.package = args.ghc; };
493493 };
494494 in { inherit (pkg-set.config) hsPkgs; inherit pkg-set; stack-nix = stack.nix; };
495495
@@ -504,7 +504,7 @@ self: super: {
504504 # Like `cabalProject'`, but for building the GHCJS compiler.
505505 # This is exposed to allow GHCJS developers to work on the GHCJS
506506 # code in a nix-shell with `shellFor`.
507− ghcjsProject = import ../lib/ghcjs-project.nix { pkgs = self; };
507+ ghcjsProject = import ../lib/ghcjs-project.nix { pkgs = final; };
508508
509509 # The functions that return a plan-nix often have a lot of dependencies
510510 # that could be GCed and also will not make it into hydra cache.
@@ -513,47 +513,47 @@ self: super: {
513513 # project = cabalProject' {...};
514514 # In your tests module add something that is effectively
515515 # testProjectPlan = withInputs project.plan-nix;
516− withInputs = self.recurseIntoAttrs;
516+ withInputs = final.recurseIntoAttrs;
517517
518518 # Add this to your tests to make all the dependencies of haskell.nix
519519 # are tested and cached.
520− haskellNixRoots = self.recurseIntoAttrs {
520+ haskellNixRoots = final.recurseIntoAttrs {
521521 Level0 = haskellNixRoots' 0;
522522 Level1 = haskellNixRoots' 1;
523523 };
524524
525525 haskellNixRoots' = ifdLevel:
526− let filterSupportedGhc = self.lib.filterAttrs (n: _: n == "ghc865" || n == "ghc883");
527− in self.recurseIntoAttrs ({
526+ let filterSupportedGhc = final.lib.filterAttrs (n: _: n == "ghc865" || n == "ghc883");
527+ in final.recurseIntoAttrs ({
528528 # Things that require no IFD to build
529− inherit (self.buildPackages.haskell-nix) nix-tools source-pins;
530− bootstap-nix-tools = self.buildPackages.haskell-nix.bootstrap.packages.nix-tools;
531− alex-plan-nix = withInputs self.buildPackages.haskell-nix.bootstrap.packages.alex-project.plan-nix;
532− happy-plan-nix = withInputs self.buildPackages.haskell-nix.bootstrap.packages.happy-project.plan-nix;
533− hscolour-plan-nix = withInputs self.buildPackages.haskell-nix.bootstrap.packages.hscolour-project.plan-nix;
534− } // self.lib.optionalAttrs (ifdLevel > 0) {
529+ inherit (final.buildPackages.haskell-nix) nix-tools source-pins;
530+ bootstap-nix-tools = final.buildPackages.haskell-nix.bootstrap.packages.nix-tools;
531+ alex-plan-nix = withInputs final.buildPackages.haskell-nix.bootstrap.packages.alex-project.plan-nix;
532+ happy-plan-nix = withInputs final.buildPackages.haskell-nix.bootstrap.packages.happy-project.plan-nix;
533+ hscolour-plan-nix = withInputs final.buildPackages.haskell-nix.bootstrap.packages.hscolour-project.plan-nix;
534+ } // final.lib.optionalAttrs (ifdLevel > 0) {
535535 # Things that require one IFD to build (the inputs should be in level 0)
536− alex = self.buildPackages.haskell-nix.bootstrap.packages.alex;
537− happy = self.buildPackages.haskell-nix.bootstrap.packages.happy;
538− hscolour = self.buildPackages.haskell-nix.bootstrap.packages.hscolour;
539− ghc865 = self.buildPackages.haskell-nix.compiler.ghc865;
540− ghc883 = self.buildPackages.haskell-nix.compiler.ghc883;
541− ghc-boot-packages-nix = self.recurseIntoAttrs
542− (builtins.mapAttrs (_: self.recurseIntoAttrs)
543− (filterSupportedGhc self.ghc-boot-packages-nix));
544− ghc-extra-projects = self.recurseIntoAttrs (builtins.mapAttrs (_: proj: withInputs proj.plan-nix)
545− (filterSupportedGhc self.ghc-extra-projects));
546− } // self.lib.optionalAttrs (ifdLevel > 1) {
536+ alex = final.buildPackages.haskell-nix.bootstrap.packages.alex;
537+ happy = final.buildPackages.haskell-nix.bootstrap.packages.happy;
538+ hscolour = final.buildPackages.haskell-nix.bootstrap.packages.hscolour;
539+ ghc865 = final.buildPackages.haskell-nix.compiler.ghc865;
540+ ghc883 = final.buildPackages.haskell-nix.compiler.ghc883;
541+ ghc-boot-packages-nix = final.recurseIntoAttrs
542+ (builtins.mapAttrs (_: final.recurseIntoAttrs)
543+ (filterSupportedGhc final.ghc-boot-packages-nix));
544+ ghc-extra-projects = final.recurseIntoAttrs (builtins.mapAttrs (_: proj: withInputs proj.plan-nix)
545+ (filterSupportedGhc final.ghc-extra-projects));
546+ } // final.lib.optionalAttrs (ifdLevel > 1) {
547547 # Things that require two levels of IFD to build (inputs should be in level 1)
548− inherit (self.haskell-nix) nix-tools;
548+ inherit (final.haskell-nix) nix-tools;
549549 # These seem to be the only things we use from `ghc-extra-packages`
550− # in haskell.nix itself.
551− iserv-proxy = self.recurseIntoAttrs
550+ # in haskell.nix itfinal.
551+ iserv-proxy = final.recurseIntoAttrs
552552 (builtins.mapAttrs (_: pkgs: pkgs.iserv-proxy.components.exes.iserv-proxy)
553− (filterSupportedGhc self.ghc-extra-packages));
554− remote-iserv = self.recurseIntoAttrs
553+ (filterSupportedGhc final.ghc-extra-packages));
554+ remote-iserv = final.recurseIntoAttrs
555555 (builtins.mapAttrs (_: pkgs: pkgs.remote-iserv.components.exes.remote-iserv)
556− (filterSupportedGhc self.ghc-extra-packages));
556+ (filterSupportedGhc final.ghc-extra-packages));
557557 });
558558 };
559559}