2017-04-12 18:28:06 +01:00
# This expression takes a file like `hackage-packages.nix` and constructs
# a full package set out of that.
2017-09-10 20:36:48 +01:00
{ # package-set used for build tools (all of nixpkgs)
buildPackages
2018-01-04 21:18:02 +00:00
, # A haskell package set for Setup.hs, compiler plugins, and similar
# build-time uses.
buildHaskellPackages
2017-09-10 20:36:48 +01:00
, # package-set used for non-haskell dependencies (all of nixpkgs)
2017-08-01 17:44:08 +01:00
pkgs
2017-04-12 18:28:06 +01:00
2017-08-01 17:44:08 +01:00
, # stdenv to use for building haskell packages
stdenv
, haskellLib
, # hashes for downloading Hackage packages
all-cabal-hashes
, # compiler to use
ghc
2018-01-04 21:18:02 +00:00
, # A function that takes `{ pkgs, stdenv, callPackage }` as the first arg and
# `self` as second, and returns a set of haskell packages
2017-08-01 17:44:08 +01:00
package-set
, # The final, fully overriden package set usable with the nixpkgs fixpoint
# overriding functionality
extensible-self
} :
2017-04-12 18:28:06 +01:00
# return value: a function from self to the package set
2017-08-06 20:46:49 +01:00
self :
let
2017-09-10 20:36:48 +01:00
inherit ( stdenv ) buildPlatform hostPlatform ;
2017-04-12 18:28:06 +01:00
2017-09-29 14:11:26 +01:00
inherit ( stdenv . lib ) fix' extends makeOverridable ;
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
inherit ( haskellLib ) overrideCabal ;
2017-04-12 18:28:06 +01:00
mkDerivationImpl = pkgs . callPackage ./generic-builder.nix {
2017-12-28 18:23:41 +00:00
inherit stdenv ;
2017-09-10 20:36:48 +01:00
nodejs = buildPackages . nodejs-slim ;
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
inherit ( self ) buildHaskellPackages ghc ghcWithHoogle ghcWithPackages ;
2018-09-17 20:59:37 +01:00
inherit ( self . buildHaskellPackages ) jailbreak-cabal ;
hscolour = overrideCabal self . buildHaskellPackages . hscolour ( drv : {
2017-04-12 18:28:06 +01:00
isLibrary = false ;
doHaddock = false ;
hyperlinkSource = false ; # Avoid depending on hscolour for this build.
postFixup = " r m - r f $ o u t / l i b $ o u t / s h a r e $ o u t / n i x - s u p p o r t " ;
} ) ;
cpphs = overrideCabal ( self . cpphs . overrideScope ( self : super : {
mkDerivation = drv : super . mkDerivation ( drv // {
enableSharedExecutables = false ;
enableSharedLibraries = false ;
doHaddock = false ;
useCpphs = false ;
} ) ;
} ) ) ( drv : {
isLibrary = false ;
postFixup = " r m - r f $ o u t / l i b $ o u t / s h a r e $ o u t / n i x - s u p p o r t " ;
} ) ;
} ;
mkDerivation = makeOverridable mkDerivationImpl ;
2017-09-29 14:11:26 +01:00
# manualArgs are the arguments that were explictly passed to `callPackage`, like:
#
# callPackage foo { bar = null; };
#
# here `bar` is a manual argument.
callPackageWithScope = scope : fn : manualArgs :
let
# this code is copied from callPackage in lib/customisation.nix
#
# we cannot use `callPackage` here because we want to call `makeOverridable`
# on `drvScope` (we cannot add `overrideScope` after calling `callPackage` because then it is
# lost on `.override`) but determine the auto-args based on `drv` (the problem here
# is that nix has no way to "passthrough" args while preserving the reflection
# info that callPackage uses to determine the arguments).
2018-01-31 19:02:19 +00:00
drv = if stdenv . lib . isFunction fn then fn else import fn ;
auto = builtins . intersectAttrs ( stdenv . lib . functionArgs drv ) scope ;
2017-09-29 14:11:26 +01:00
# this wraps the `drv` function to add a `overrideScope` function to the result.
drvScope = allArgs : drv allArgs // {
overrideScope = f :
let newScope = mkScope ( fix' ( extends f scope . __unfix__ ) ) ;
# note that we have to be careful here: `allArgs` includes the auto-arguments that
# weren't manually specified. If we would just pass `allArgs` to the recursive call here,
# then we wouldn't look up any packages in the scope in the next interation, because it
# appears as if all arguments were already manually passed, so the scope change would do
# nothing.
in callPackageWithScope newScope drv manualArgs ;
} ;
in stdenv . lib . makeOverridable drvScope ( auto // manualArgs ) ;
2018-07-07 19:28:42 +01:00
mkScope = scope : let
ps = pkgs . __splicedPackages ;
scopeSpliced = pkgs . splicePackages {
pkgsBuildBuild = scope . buildHaskellPackages . buildHaskellPackages ;
pkgsBuildHost = scope . buildHaskellPackages ;
pkgsBuildTarget = { } ;
pkgsHostHost = { } ;
pkgsHostTarget = scope ;
pkgsTargetTarget = { } ;
} // {
# Don't splice these
inherit ( scope ) ghc buildHaskellPackages ;
} ;
in ps // ps . xorg // ps . gnome2 // { inherit stdenv ; } // scopeSpliced ;
2017-04-12 18:28:06 +01:00
defaultScope = mkScope self ;
2017-09-29 14:11:26 +01:00
callPackage = drv : args : callPackageWithScope defaultScope drv args ;
2017-04-12 18:28:06 +01:00
2018-01-03 04:39:28 +00:00
withPackages = packages : buildPackages . callPackage ./with-packages-wrapper.nix {
2018-06-07 19:27:44 +01:00
inherit ( self ) ghc llvmPackages ;
2017-04-12 18:28:06 +01:00
inherit packages ;
} ;
2019-05-14 06:18:02 +01:00
# Use cabal2nix to create a default.nix for the package sources found at 'src'.
2018-03-09 13:47:47 +00:00
haskellSrc2nix = { name , src , sha256 ? null , extraCabal2nixOptions ? " " }:
2017-04-12 18:28:06 +01:00
let
2019-04-24 04:48:22 +01:00
sha256Arg = if sha256 == null then " - - s h a 2 5 6 = " else '' - - s h a 2 5 6 = " ${ sha256 } " '' ;
2019-10-01 17:35:51 +01:00
in buildPackages . stdenv . mkDerivation {
2017-04-12 18:28:06 +01:00
name = " c a b a l 2 n i x - ${ name } " ;
2020-02-26 14:26:14 +00:00
nativeBuildInputs = [ buildPackages . cabal2nix-unwrapped ] ;
2017-05-01 23:21:42 +01:00
preferLocalBuild = true ;
2018-11-06 14:17:07 +00:00
allowSubstitutes = false ;
2017-04-12 18:28:06 +01:00
phases = [ " i n s t a l l P h a s e " ] ;
LANG = " e n _ U S . U T F - 8 " ;
2018-07-17 14:42:55 +01:00
LOCALE_ARCHIVE = pkgs . lib . optionalString ( buildPlatform . libc == " g l i b c " ) " ${ buildPackages . glibcLocales } / l i b / l o c a l e / l o c a l e - a r c h i v e " ;
2017-04-12 18:28:06 +01:00
installPhase = ''
export HOME = " $ T M P "
mkdir - p " $ o u t "
2019-10-15 16:22:19 +01:00
cabal2nix - - compiler = $ { self . ghc . haskellCompilerName } - - system = $ { hostPlatform . config } $ { sha256Arg } " ${ src } " $ { extraCabal2nixOptions } > " $ o u t / d e f a u l t . n i x "
2017-04-12 18:28:06 +01:00
'' ;
} ;
2019-10-01 17:35:51 +01:00
all-cabal-hashes-component = name : version : buildPackages . runCommand " a l l - c a b a l - h a s h e s - c o m p o n e n t - ${ name } - ${ version } " { } ''
2017-11-06 21:26:05 +00:00
tar - - wildcards - xzvf $ { all-cabal-hashes } \ * / $ { name } / $ { version } / $ { name } . { json , cabal }
mkdir - p $ out
mv * / $ { name } / $ { version } / $ { name } . { json , cabal } $ out
'' ;
hackage2nix = name : version : let component = all-cabal-hashes-component name version ; in self . haskellSrc2nix {
2017-04-12 18:28:06 +01:00
name = " ${ name } - ${ version } " ;
2017-11-06 21:26:05 +00:00
sha256 = '' $( s e d - e ' s / . * " S H A 2 5 6 " : " / / ' - e ' s / " . * $/ / ' " ${ component } / ${ name } . j s o n " ) '' ;
src = " ${ component } / ${ name } . c a b a l " ;
2017-04-12 18:28:06 +01:00
} ;
2018-03-25 08:12:28 +01:00
# Adds a nix file as an input to the haskell derivation it
# produces. This is useful for callHackage / callCabal2nix to
# prevent the generated default.nix from being garbage collected
# (requiring it to be frequently rebuilt), which can be an
# annoyance.
callPackageKeepDeriver = src : args :
overrideCabal ( self . callPackage src args ) ( orig : {
preConfigure = ''
# Generated from ${src}
$ { orig . preConfigure or " " }
'' ;
2018-08-02 14:48:06 +01:00
passthru = orig . passthru or { } // {
# When using callCabal2nix or callHackage, it is often useful
# to debug a failure by inspecting the Nix expression
# generated by cabal2nix. This can be accessed via this
# cabal2nixDeriver field.
cabal2nixDeriver = src ;
} ;
2018-03-25 08:12:28 +01:00
} ) ;
2017-04-12 18:28:06 +01:00
in package-set { inherit pkgs stdenv callPackage ; } self // {
2018-07-07 19:28:42 +01:00
inherit mkDerivation callPackage haskellSrc2nix hackage2nix buildHaskellPackages ;
2017-04-12 18:28:06 +01:00
2018-01-18 21:37:47 +00:00
inherit ( haskellLib ) packageSourceOverrides ;
2019-05-14 06:18:02 +01:00
# callHackage :: Text -> Text -> AttrSet -> HaskellPackage
#
# e.g., while overriding a package set:
# '... foo = self.callHackage "foo" "1.5.3" {}; ...'
2018-03-25 08:12:28 +01:00
callHackage = name : version : callPackageKeepDeriver ( self . hackage2nix name version ) ;
2017-04-12 18:28:06 +01:00
2019-11-20 06:36:33 +00:00
# callHackageDirect
# :: { pkg :: Text, ver :: Text, sha256 :: Text }
# -> AttrSet
# -> HaskellPackage
2019-05-14 06:18:02 +01:00
#
2018-12-25 17:19:24 +00:00
# This function does not depend on all-cabal-hashes and therefore will work
# for any version that has been released on hackage as opposed to only
# versions released before whatever version of all-cabal-hashes you happen
# to be currently using.
2019-06-16 20:59:06 +01:00
callHackageDirect = { pkg , ver , sha256 }:
2018-12-25 17:19:24 +00:00
let pkgver = " ${ pkg } - ${ ver } " ;
in self . callCabal2nix pkg ( pkgs . fetchzip {
2019-04-05 18:49:48 +01:00
url = " m i r r o r : / / h a c k a g e / ${ pkgver } / ${ pkgver } . t a r . g z " ;
2018-12-25 17:19:24 +00:00
inherit sha256 ;
2019-01-27 17:28:01 +00:00
} ) ;
2018-12-25 17:19:24 +00:00
2017-04-12 18:28:06 +01:00
# Creates a Haskell package from a source package by calling cabal2nix on the source.
2018-08-03 20:55:29 +01:00
callCabal2nixWithOptions = name : src : extraCabal2nixOptions : args :
let
filter = path : type :
pkgs . lib . hasSuffix " ${ name } . c a b a l " path ||
baseNameOf path == " p a c k a g e . y a m l " ;
expr = self . haskellSrc2nix {
inherit name extraCabal2nixOptions ;
src = if pkgs . lib . canCleanSource src
then pkgs . lib . cleanSourceWith { inherit src filter ; }
else src ;
} ;
in overrideCabal ( callPackageKeepDeriver expr args ) ( orig : {
inherit src ;
} ) ;
callCabal2nix = name : src : args : self . callCabal2nixWithOptions name src " " args ;
2017-04-12 18:28:06 +01:00
2017-06-13 00:29:46 +01:00
# : { root : Path
2018-10-15 21:15:03 +01:00
# , name : Defaulted String
2017-06-24 11:42:56 +01:00
# , source-overrides : Defaulted (Either Path VersionNumber)
2017-06-13 00:29:46 +01:00
# , overrides : Defaulted (HaskellPackageOverrideSet)
2018-01-30 03:29:59 +00:00
# , modifier : Defaulted
2018-05-16 06:02:00 +01:00
# , returnShellEnv : Defaulted
2017-06-13 00:29:46 +01:00
# } -> NixShellAwareDerivation
2018-10-17 19:44:07 +01:00
# Given a path to a haskell package directory, an optional package name
# which defaults to the base name of the path, an optional set of source
# overrides as appropriate for the 'packageSourceOverrides' function, an
# optional set of arbitrary overrides, and an optional haskell package
# modifier, return a derivation appropriate for nix-build or nix-shell to
# build that package.
2018-05-16 06:02:00 +01:00
developPackage =
{ root
2018-10-15 21:15:03 +01:00
, name ? builtins . baseNameOf root
2018-05-16 06:02:00 +01:00
, source-overrides ? { }
, overrides ? self : super : { }
, modifier ? drv : drv
, returnShellEnv ? pkgs . lib . inNixShell } :
let drv =
( extensible-self . extend
( pkgs . lib . composeExtensions
( self . packageSourceOverrides source-overrides )
overrides ) )
2018-10-15 21:15:03 +01:00
. callCabal2nix name root { } ;
2018-05-16 06:02:00 +01:00
in if returnShellEnv then ( modifier drv ) . env else modifier drv ;
2017-06-11 01:04:46 +01:00
2017-04-12 18:28:06 +01:00
ghcWithPackages = selectFrom : withPackages ( selectFrom self ) ;
ghcWithHoogle = selectFrom :
let
packages = selectFrom self ;
hoogle = callPackage ./hoogle.nix {
inherit packages ;
} ;
in withPackages ( packages ++ [ hoogle ] ) ;
2018-03-06 20:37:05 +00:00
# Returns a derivation whose environment contains a GHC with only
# the dependencies of packages listed in `packages`, not the
# packages themselves. Using nix-shell on this derivation will
# give you an environment suitable for developing the listed
# packages with an incremental tool like cabal-install.
2020-11-03 07:45:15 +00:00
#
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
# In addition to the "packages" arg and "withHoogle" arg, anything that
# can be passed into stdenv.mkDerivation can be included in the input attrset
2018-03-06 20:37:05 +00:00
#
# # default.nix
# with import <nixpkgs> {};
# haskellPackages.extend (haskell.lib.packageSourceOverrides {
# frontend = ./frontend;
# backend = ./backend;
# common = ./common;
# })
#
# # shell.nix
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
# let pkgs = import <nixpkgs> {} in
2018-03-06 20:37:05 +00:00
# (import ./.).shellFor {
# packages = p: [p.frontend p.backend p.common];
# withHoogle = true;
2020-11-03 07:45:15 +00:00
# buildInputs = [ pkgs.python pkgs.cabal-install ];
2018-03-06 20:37:05 +00:00
# }
#
# -- cabal.project
# packages:
# frontend/
# backend/
# common/
#
# bash$ nix-shell --run "cabal new-build all"
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
# bash$ nix-shell --run "python"
2020-11-03 07:45:15 +00:00
shellFor =
{ # Packages to create this development shell for. These are usually
# your local packages.
packages
2020-11-04 00:18:56 +00:00
, # Whether or not to generate a Hoogle database for all the
2020-11-03 07:45:15 +00:00
# dependencies.
withHoogle ? false
2020-11-04 01:00:30 +00:00
, # Whether or not to include benchmark dependencies of your local
# packages. You should set this to true if you have benchmarks defined
# in your local packages that you want to be able to run with cabal benchmark
doBenchmark ? false
2020-11-03 07:45:15 +00:00
, . . .
} @ args :
2018-03-06 20:37:05 +00:00
let
2020-11-03 07:45:15 +00:00
# A list of the packages we want to build a development shell for.
# This is a list of Haskell package derivations.
selected = packages self ;
2020-11-04 00:18:56 +00:00
# This is a list of attribute sets, where each attribute set
# corresponds to the build inputs of one of the packages input to shellFor.
2020-11-03 07:45:15 +00:00
#
# Each attribute has keys like buildDepends, executableHaskellDepends,
# testPkgconfigDepends, etc. The values for the keys of the attribute
# set are lists of dependencies.
#
# Example:
# cabalDepsForSelected
# => [
# # This may be the attribute set corresponding to the `backend`
# # package in the example above.
# { buildDepends = [ gcc ... ];
# libraryHaskellDepends = [ lens conduit ... ];
# ...
# }
# # This may be the attribute set corresponding to the `common`
# # package in the example above.
# { testHaskellDepends = [ tasty hspec ... ];
# libraryHaskellDepends = [ lens aeson ];
# benchmarkHaskellDepends = [ criterion ... ];
# ...
# }
# ...
# ]
cabalDepsForSelected = map ( p : p . getCabalDeps ) selected ;
# A predicate that takes a derivation as input, and tests whether it is
# the same as any of the `selected` packages.
#
# Returns true if the input derivation is not in the list of `selected`
# packages.
#
# isNotSelected :: Derivation -> Bool
#
# Example:
#
# isNotSelected common [ frontend backend common ]
# => false
#
# isNotSelected lens [ frontend backend common ]
# => true
isNotSelected = input : pkgs . lib . all ( p : input . outPath or null != p . outPath ) selected ;
# A function that takes a list of list of derivations, filters out all
# the `selected` packages from each list, and concats the results.
#
# zipperCombinedPkgs :: [[Derivation]] -> [Derivation]
#
# Example:
# zipperCombinedPkgs [ [ lens conduit ] [ aeson frontend ] ]
# => [ lens conduit aeson ]
#
# Note: The reason this isn't just the function `pkgs.lib.concat` is
# that we need to be careful to remove dependencies that are in the
# `selected` packages.
#
# For instance, in the above example, if `common` is a dependency of
# `backend`, then zipperCombinedPkgs needs to be careful to filter out
# `common`, because cabal will end up ignoring that built version,
# assuming new-style commands.
zipperCombinedPkgs = vals :
pkgs . lib . concatMap
( drvList : pkgs . lib . filter isNotSelected drvList )
vals ;
# Zip `cabalDepsForSelected` into a single attribute list, combining
# the derivations in all the individual attributes.
#
# Example:
# packageInputs
# => # Assuming the value of cabalDepsForSelected is the same as
# # the example in cabalDepsForSelected:
# { buildDepends = [ gcc ... ];
# libraryHaskellDepends = [ lens conduit aeson ... ];
# testHaskellDepends = [ tasty hspec ... ];
# benchmarkHaskellDepends = [ criterion ... ];
# ...
# }
#
# See the Note in `zipperCombinedPkgs` for what gets filtered out from
# each of these dependency lists.
packageInputs =
pkgs . lib . zipAttrsWith ( _name : zipperCombinedPkgs ) cabalDepsForSelected ;
# A attribute set to pass to `haskellPackages.mkDerivation`.
#
# The important thing to note here is that all the fields from
# packageInputs are set correctly.
genericBuilderArgs = {
pname =
if pkgs . lib . length selected == 1
then ( pkgs . lib . head selected ) . name
else " p a c k a g e s " ;
version = " 0 " ;
license = null ;
}
2020-11-04 01:00:30 +00:00
// packageInputs
// pkgs . lib . optionalAttrs doBenchmark {
# `doBenchmark` needs to explicitly be set here because haskellPackages.mkDerivation defaults it to `false`. If the user wants benchmark dependencies included in their development shell, it has to be explicitly enabled here.
doBenchmark = true ;
} ;
2020-11-03 07:45:15 +00:00
# This is a pseudo Haskell package derivation that contains all the
# dependencies for the packages in `selected`.
#
# This is a derivation created with `haskellPackages.mkDerivation`.
#
# pkgWithCombinedDeps :: HaskellDerivation
pkgWithCombinedDeps = self . mkDerivation genericBuilderArgs ;
# The derivation returned from `envFunc` for `pkgWithCombinedDeps`.
#
# This is a derivation that can be run with `nix-shell`. It provides a
# GHC with a package database with all the dependencies of our
# `selected` packages.
#
# This is a derivation created with `stdenv.mkDerivation` (not
# `haskellPackages.mkDerivation`).
#
# pkgWithCombinedDepsDevDrv :: Derivation
pkgWithCombinedDepsDevDrv = pkgWithCombinedDeps . envFunc { inherit withHoogle ; } ;
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
2020-11-04 01:00:30 +00:00
mkDerivationArgs = builtins . removeAttrs args [ " p a c k a g e s " " w i t h H o o g l e " " d o B e n c h m a r k " ] ;
2020-11-03 07:45:15 +00:00
in pkgWithCombinedDepsDevDrv . overrideAttrs ( old : mkDerivationArgs // {
2020-02-22 18:10:30 +00:00
nativeBuildInputs = old . nativeBuildInputs ++ mkDerivationArgs . nativeBuildInputs or [ ] ;
buildInputs = old . buildInputs ++ mkDerivationArgs . buildInputs or [ ] ;
2018-03-06 20:37:05 +00:00
} ) ;
2017-04-12 18:28:06 +01:00
ghc = ghc // {
withPackages = self . ghcWithPackages ;
withHoogle = self . ghcWithHoogle ;
} ;
}