2017-04-12 17:28:06 +00:00
# This expression takes a file like `hackage-packages.nix` and constructs
# a full package set out of that.
2017-09-10 19:36:48 +00: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 19:36:48 +00:00
, # package-set used for non-haskell dependencies (all of nixpkgs)
2017-08-01 16:44:08 +00:00
pkgs
2017-04-12 17:28:06 +00:00
2021-01-19 18:26:01 +00:00
, # stdenv provides our build and host platforms
2017-08-01 16:44:08 +00:00
stdenv
2021-01-19 18:26:01 +00:00
, # this module provides the list of known licenses and maintainers
lib
# needed for overrideCabal & packageSourceOverrides
2017-08-01 16:44:08 +00:00
, haskellLib
, # hashes for downloading Hackage packages
2022-08-25 01:57:52 +00:00
# This is either a directory or a .tar.gz containing the cabal files and
# hashes of Hackage as exemplified by this repository:
# https://github.com/commercialhaskell/all-cabal-hashes/tree/hackage
2017-08-01 16:44:08 +00:00
all-cabal-hashes
, # compiler to use
ghc
2021-01-19 18:26:01 +00:00
, # A function that takes `{ pkgs, lib, callPackage }` as the first arg and
2018-01-04 21:18:02 +00:00
# `self` as second, and returns a set of haskell packages
2017-08-01 16:44:08 +00:00
package-set
2022-12-18 00:39:44 +00:00
, # The final, fully overridden package set usable with the nixpkgs fixpoint
2017-08-01 16:44:08 +00:00
# overriding functionality
extensible-self
} :
2017-04-12 17:28:06 +00:00
# return value: a function from self to the package set
2017-08-06 19:46:49 +00:00
self :
let
2017-09-10 19:36:48 +00:00
inherit ( stdenv ) buildPlatform hostPlatform ;
2017-04-12 17:28:06 +00:00
2021-01-23 17:15:07 +00:00
inherit ( 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 17:28:06 +00:00
mkDerivationImpl = pkgs . callPackage ./generic-builder.nix {
2017-12-28 18:23:41 +00:00
inherit stdenv ;
2017-09-10 19:36:48 +00: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 19:59:37 +00:00
inherit ( self . buildHaskellPackages ) jailbreak-cabal ;
2021-10-26 10:20:34 +00:00
hscolour = overrideCabal ( drv : {
2017-04-12 17:28:06 +00: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 " ;
2021-10-26 10:20:34 +00:00
} ) self . buildHaskellPackages . hscolour ;
cpphs = overrideCabal ( 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 " ;
} ) ( self . cpphs . overrideScope ( self : super : {
2017-04-12 17:28:06 +00:00
mkDerivation = drv : super . mkDerivation ( drv // {
enableSharedExecutables = false ;
enableSharedLibraries = false ;
doHaddock = false ;
useCpphs = false ;
} ) ;
2021-10-26 10:20:34 +00:00
} ) ) ;
2017-04-12 17:28:06 +00:00
} ;
mkDerivation = makeOverridable mkDerivationImpl ;
2022-12-18 00:39:44 +00:00
# manualArgs are the arguments that were explicitly passed to `callPackage`, like:
2017-09-29 13:11:26 +00:00
#
# 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).
2021-01-23 17:15:07 +00:00
drv = if lib . isFunction fn then fn else import fn ;
auto = builtins . intersectAttrs ( lib . functionArgs drv ) scope ;
2017-09-29 13:11:26 +00:00
2021-11-20 15:31:02 +00:00
# Converts a returned function to a functor attribute set if necessary
ensureAttrs = v : if builtins . isFunction v then { __functor = _ : v ; } else v ;
2022-12-13 00:02:01 +00:00
# this wraps the `drv` function to add `scope` and `overrideScope` to the result.
2021-11-20 15:31:02 +00:00
drvScope = allArgs : ensureAttrs ( drv allArgs ) // {
2022-12-13 00:02:01 +00:00
inherit scope ;
2017-09-29 13:11:26 +00:00
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 ;
} ;
2021-01-23 17:15:07 +00:00
in lib . makeOverridable drvScope ( auto // manualArgs ) ;
2017-09-29 13:11:26 +00:00
2018-07-07 18:28:42 +00: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 17:28:06 +00:00
defaultScope = mkScope self ;
2017-09-29 13:11:26 +00:00
callPackage = drv : args : callPackageWithScope defaultScope drv args ;
2017-04-12 17:28:06 +00:00
2019-05-14 05:18:02 +00: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 17:28:06 +00:00
let
2019-04-24 03:48:22 +00:00
sha256Arg = if sha256 == null then " - - s h a 2 5 6 = " else '' - - s h a 2 5 6 = " ${ sha256 } " '' ;
2022-02-26 12:38:11 +00:00
in buildPackages . runCommand " 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 22:21:42 +00:00
preferLocalBuild = true ;
2018-11-06 14:17:07 +00:00
allowSubstitutes = false ;
2017-04-12 17:28:06 +00:00
LANG = " e n _ U S . U T F - 8 " ;
2018-07-17 13:42:55 +00: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 " ;
2022-02-26 12:38:11 +00:00
} ''
export HOME = " $ T M P "
mkdir - p " $ o u t "
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 17:28:06 +00:00
2022-08-25 01:57:52 +00:00
# Given a package name and version, e.g. name = "async", version = "2.2.4",
# gives its cabal file and hashes (JSON file) as discovered from the
# all-cabal-hashes value. If that's a directory, it will copy the relevant
# files to $out; if it's a tarball, it will extract and move them to $out.
2019-10-01 16:35:51 +00: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
mkdir - p $ out
2022-08-25 01:57:52 +00:00
if [ - d $ { all-cabal-hashes } ]
then
cp $ { all-cabal-hashes } / $ { name } / $ { version } / $ { name } . json $ out
cp $ { all-cabal-hashes } / $ { name } / $ { version } / $ { name } . cabal $ out
else
tar - - wildcards - xzvf $ { all-cabal-hashes } \ * / $ { name } / $ { version } / $ { name } . { json , cabal }
mv * / $ { name } / $ { version } / $ { name } . { json , cabal } $ out
fi
2017-11-06 21:26:05 +00:00
'' ;
hackage2nix = name : version : let component = all-cabal-hashes-component name version ; in self . haskellSrc2nix {
2017-04-12 17:28:06 +00: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 17:28:06 +00:00
} ;
haskellPackages.callHackage: updating all-cabal-hashes do not invalidate callHackage
Packages built with `haskellPackages.callHackage` won't be rebuilt when
updating `all-cabal-hashes`.
The removed comment was keeping a reference to the `cabal2nix` call,
which itself depends on `all-cabal-hashes`, in order to keep this file
during a garbage collection.
The tradeoff is between:
- The current behavior: a mass rebuild, any change of `all-cabal-hashes`
triggers a rebuild of all the packages built with `callHackage` and
packages which depend on them. This can take hours, and may happen
after a "small" unrelated change (i.e. an user is bumping
`all-cabal-hashes` in order to use a new package from hackage). It
also have global impacts in a project (long rebuild in CI, new entries
in cache, developers need to fetch the new entries, ...). In this
context, `cabal2nix` entries are not garbage collected.
- The new behavior: No mass rebuild, but `cabal2nix` derivations need to
be recomputed after a garbage collection. This is usually fast (a few
seconds by call), linear with the number of calls and should not
happen a lot (i.e. users are not garbage collecting everyday).
See https://github.com/NixOS/nixpkgs/issues/194751 for details.
2022-10-06 13:38:12 +00:00
# Adds a nix file derived from cabal2nix in the passthru of the derivation it
# produces. This is useful to debug callHackage / callCabal2nix by looking at
# the content of the nix file pointed by `cabal2nixDeriver`.
# However, it does not keep a reference to that file, which may be garbage
# collected, which may be an annoyance.
2018-03-25 07:12:28 +00:00
callPackageKeepDeriver = src : args :
2021-11-08 10:33:48 +00:00
overrideCabal ( orig : {
2018-08-02 13:48:06 +00: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 ;
} ;
2021-11-08 10:33:48 +00:00
} ) ( self . callPackage src args ) ;
2018-03-25 07:12:28 +00:00
2021-01-19 18:26:01 +00:00
in package-set { inherit pkgs lib callPackage ; } self // {
2017-04-12 17:28:06 +00:00
2018-07-07 18:28:42 +00:00
inherit mkDerivation callPackage haskellSrc2nix hackage2nix buildHaskellPackages ;
2017-04-12 17:28:06 +00:00
2018-01-18 21:37:47 +00:00
inherit ( haskellLib ) packageSourceOverrides ;
2019-05-14 05:18:02 +00:00
# callHackage :: Text -> Text -> AttrSet -> HaskellPackage
#
# e.g., while overriding a package set:
# '... foo = self.callHackage "foo" "1.5.3" {}; ...'
2018-03-25 07:12:28 +00:00
callHackage = name : version : callPackageKeepDeriver ( self . hackage2nix name version ) ;
2017-04-12 17:28:06 +00:00
2019-11-20 06:36:33 +00:00
# callHackageDirect
# :: { pkg :: Text, ver :: Text, sha256 :: Text }
# -> AttrSet
# -> HaskellPackage
2019-05-14 05:18:02 +00: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 19:59:06 +00: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 17:49:48 +00: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 17:28:06 +00:00
# Creates a Haskell package from a source package by calling cabal2nix on the source.
2018-08-03 19:55:29 +00:00
callCabal2nixWithOptions = name : src : extraCabal2nixOptions : args :
let
filter = path : type :
2021-10-27 16:17:10 +00:00
pkgs . lib . hasSuffix " . c a b a l " path ||
2018-08-03 19:55:29 +00:00
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 ;
} ;
2021-11-08 10:33:48 +00:00
in overrideCabal ( orig : {
2018-08-03 19:55:29 +00:00
inherit src ;
2021-11-08 10:33:48 +00:00
} ) ( callPackageKeepDeriver expr args ) ;
2018-08-03 19:55:29 +00:00
callCabal2nix = name : src : args : self . callCabal2nixWithOptions name src " " args ;
2017-04-12 17:28:06 +00:00
2017-06-12 23:29:46 +00:00
# : { root : Path
2018-10-15 20:15:03 +00:00
# , name : Defaulted String
2017-06-24 10:42:56 +00:00
# , source-overrides : Defaulted (Either Path VersionNumber)
2017-06-12 23:29:46 +00:00
# , overrides : Defaulted (HaskellPackageOverrideSet)
2018-01-30 03:29:59 +00:00
# , modifier : Defaulted
2018-05-16 05:02:00 +00:00
# , returnShellEnv : Defaulted
2020-11-11 03:02:05 +00:00
# , withHoogle : Defaulted
2020-11-13 05:37:40 +00:00
# , cabal2nixOptions : Defaulted
2017-06-12 23:29:46 +00:00
# } -> NixShellAwareDerivation
2020-11-13 05:37:40 +00:00
#
2018-10-17 18:44:07 +00: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.
2020-11-13 05:37:40 +00:00
#
2020-11-11 03:01:53 +00:00
# If 'returnShellEnv' is true this returns a derivation which will give you
# an environment suitable for developing the listed packages with an
# incremental tool like cabal-install.
2020-11-13 05:37:40 +00:00
#
2020-11-11 03:02:05 +00:00
# If 'withHoogle' is true (the default if a shell environment is requested)
# then 'ghcWithHoogle' is used to generate the derivation (instead of
# 'ghcWithPackages'), see the documentation there for more information.
2020-11-13 05:37:40 +00:00
#
# 'cabal2nixOptions' can contain extra command line arguments to pass to
# 'cabal2nix' when generating the package derivation, for example setting
# a cabal flag with '--flag=myflag'.
2018-05-16 05:02:00 +00:00
developPackage =
{ root
2023-02-06 20:49:02 +00:00
, name ? lib . optionalString ( builtins . typeOf root == " p a t h " ) ( builtins . baseNameOf root )
2018-05-16 05:02:00 +00:00
, source-overrides ? { }
, overrides ? self : super : { }
, modifier ? drv : drv
2020-11-11 03:02:05 +00:00
, returnShellEnv ? pkgs . lib . inNixShell
2020-11-13 05:37:40 +00:00
, withHoogle ? returnShellEnv
, cabal2nixOptions ? " " } :
2018-05-16 05:02:00 +00:00
let drv =
( extensible-self . extend
( pkgs . lib . composeExtensions
( self . packageSourceOverrides source-overrides )
overrides ) )
2020-11-13 05:37:40 +00:00
. callCabal2nixWithOptions name root cabal2nixOptions { } ;
2020-11-11 03:02:05 +00:00
in if returnShellEnv
then ( modifier drv ) . envFunc { inherit withHoogle ; }
else modifier drv ;
2017-06-11 00:04:46 +00:00
2021-11-20 16:43:12 +00:00
# This can be used to easily create a derivation containing GHC and the specified set of Haskell packages.
#
# Example:
# $ nix-shell -p 'haskellPackages.ghcWithPackages (hpkgs: [ hpkgs.mtl hpkgs.lens ])'
# $ ghci # in the nix-shell
# Prelude > import Control.Lens
#
# GHC is setup with a package database with all the specified Haskell packages.
#
# ghcWithPackages :: (HaskellPkgSet -> [ HaskellPkg ]) -> Derivation
haskellPackages: ghcWithPackages needs buildHaskellPackages scope
ghc and also ghcWithPackages (when taken from a haskell package set) are
a bit weird—in the same way stdenv is: ghc is actually from
buildPackages (pkgsBuildHost) wheras the main package set belongs to
pkgsHostTarget. ghc (and stdenv) is included in the package set due to
its special relation to the set: it is built by that ghc, so constituted
by the compiler in a manner of speaking.
For ghc this works in a straightforward way: It is packaged
independently from the haskell package sets and passed to
make-package-set.nix to create the different sets we expose.
With ghcWithPackages an error crept in, though: Since it needs to
receive the haskellPackages fix point (and thus can't be instantiated
before the package set), it is defined in make-package-set.nix. Here it
was neglected to make sure that it also has the same scope as ghc, i.e.
buildHaskellPackages/buildPackages: Otherwise the shell the wrapper
scripts use to invoke ghc (originally from buildPackages) would be from
pkgsHostTarget—in the cross case, the wrapper scripts would be
executable by neither host nor build platform. We want them to work on
the build platform, though.
Note that this creates a weird mismatch where it is hard to see which of
the alternatives would be more natural: ghcWithPackages and
ghcWithHoogle now use packages from the package set they are a member
of, but have *-ghc and hoogle executables that are executable on the
build platform. This works because ghc originates from buildPackages (as
discussed) and hoogleWithPackages is taken from buildHaskellPackages.
This does imply though that while set.ghcWithHoogle will be executable
on the build platform, set.hoogleWithPackages will be executable on the
host platform—both will use the fix point of set for the package
selector function. This is maybe a confusing asymmetry, but it seems
like a valid use case to cross-compile a hoogle instance. Most
development tools use ghcWithHoogle (or equivalent), so that use case is
covered as well in principle.
2023-05-05 16:58:08 +00:00
ghcWithPackages = buildHaskellPackages . callPackage ./with-packages-wrapper.nix {
2021-11-20 16:43:12 +00:00
haskellPackages = self ;
2023-06-14 09:03:13 +00:00
inherit ( self ) hoogleWithPackages ;
2021-11-20 16:43:12 +00:00
} ;
2017-04-12 17:28:06 +00:00
2020-11-11 03:01:53 +00:00
# Put 'hoogle' into the derivation's PATH with a database containing all
# the package's dependencies; run 'hoogle server --local' in a shell to
# host a search engine for the dependencies.
#
2021-11-20 16:43:12 +00:00
# Example usage:
# $ nix-shell -p 'haskellPackages.hoogleWithPackages (p: [ p.mtl p.lens ])'
# [nix-shell] $ hoogle server
#
# hoogleWithPackages :: (HaskellPkgSet -> [ HaskellPkg ]) -> Derivation
#
2020-11-11 03:01:53 +00:00
# To reload the Hoogle server automatically on .cabal file changes try
# this:
# echo *.cabal | entr -r -- nix-shell --run 'hoogle server --local'
2021-11-20 16:43:12 +00:00
hoogleWithPackages = self . callPackage ./hoogle.nix {
haskellPackages = self ;
} ;
hoogleLocal =
{ packages ? [ ] }:
lib . warn " h o o g l e L o c a l i s d e p r e c a t e d , u s e h o o g l e W i t h P a c k a g e s i n s t e a d " (
self . hoogleWithPackages ( _ : packages )
) ;
# This is like a combination of ghcWithPackages and hoogleWithPackages.
# It provides a derivation containing both GHC and Hoogle with an index of
# the given Haskell package database.
#
# Example:
# $ nix-shell -p 'haskellPackages.ghcWithHoogle (hpkgs: [ hpkgs.conduit hpkgs.lens ])'
#
# ghcWithHoogle :: (HaskellPkgSet -> [ HaskellPkg ]) -> Derivation
ghcWithHoogle = self . ghcWithPackages . override {
withHoogle = true ;
} ;
2017-04-12 17:28:06 +00:00
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> {};
2021-10-26 10:20:34 +00:00
# haskellPackages.extend (haskell.lib.compose.packageSourceOverrides {
2018-03-06 20:37:05 +00:00
# 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
2021-01-14 16:36:42 +00:00
# An optional function that can modify the generic builder arguments
# for the fake package that shellFor uses to construct its environment.
#
# Example:
# let
# # elided...
# haskellPkgs = pkgs.haskell.packages.ghc884.override (hpArgs: {
# overrides = pkgs.lib.composeExtensions (hpArgs.overrides or (_: _: { })) (
# _hfinal: hprev: {
# mkDerivation = args: hprev.mkDerivation ({
# doCheck = false;
# doBenchmark = false;
# doHoogle = true;
# doHaddock = true;
# enableLibraryProfiling = false;
# enableExecutableProfiling = false;
# } // args);
# }
# );
# });
# in
2021-07-12 03:29:53 +00:00
# haskellPkgs.shellFor {
2021-01-14 16:36:42 +00:00
# packages = p: [ p.foo ];
# genericBuilderArgsModifier = args: args // { doCheck = true; doBenchmark = true };
# }
#
# This will disable tests and benchmarks for everything in "haskellPkgs"
# (which will invalidate the binary cache), and then re-enable them
# for the "shellFor" environment (ensuring that any test/benchmark
# dependencies for "foo" will be available within the nix-shell).
2021-01-11 22:47:24 +00:00
, genericBuilderArgsModifier ? ( args : args )
2022-03-15 19:36:31 +00:00
# Extra dependencies, in the form of cabal2nix build attributes.
#
# An example use case is when you have Haskell scripts that use
# libraries that don't occur in your packages' dependencies.
#
# Example:
#
# extraDependencies = p: {
# libraryHaskellDepends = [ p.releaser ];
# };
, extraDependencies ? p : { }
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 =
2022-03-15 19:36:31 +00:00
pkgs . lib . zipAttrsWith ( _name : zipperCombinedPkgs ) ( cabalDepsForSelected ++ [ ( extraDependencies self ) ] ) ;
2020-11-03 07:45:15 +00:00
# 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
2021-01-11 22:47:24 +00:00
pkgWithCombinedDeps = self . mkDerivation ( genericBuilderArgsModifier genericBuilderArgs ) ;
2020-11-03 07:45:15 +00:00
# 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
2022-03-15 19:36:31 +00:00
mkDerivationArgs = builtins . removeAttrs args [ " g e n e r i c B u i l d e r A r g s M o d i f i e r " " 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 " " e x t r a D e p e n d e n c i e s " ] ;
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 17:28:06 +00:00
ghc = ghc // {
withPackages = self . ghcWithPackages ;
withHoogle = self . ghcWithHoogle ;
} ;
2022-05-23 19:39:01 +00:00
/*
Run ` cabal sdist ` on a source .
Unlike ` haskell . lib . sdistTarball ` , this does not require any dependencies
to be present , as it uses ` cabal-install ` instead of building ` Setup . hs ` .
This makes ` cabalSdist ` faster than ` sdistTarball ` .
* /
cabalSdist = {
src ,
name ? if src ? name then " ${ src . name } - s d i s t . t a r . g z " else " s o u r c e . t a r . g z "
} :
2022-06-29 19:20:31 +00:00
pkgs . runCommandLocal name
2022-05-23 19:39:01 +00:00
{
inherit src ;
2022-08-21 10:46:45 +00:00
nativeBuildInputs = [
buildHaskellPackages . cabal-install
# TODO after https://github.com/haskell/cabal/issues/8352
# remove ghc
self . ghc
] ;
2022-05-23 19:39:01 +00:00
dontUnpack = false ;
} ''
unpackPhase
cd " ' ' ${ sourceRoot:-. } "
patchPhase
mkdir out
HOME = $ PWD cabal sdist - - output-directory out
mv out /* . t a r . g z $ o u t
'' ;
/*
Like ` haskell . lib . buildFromSdist ` , but using ` cabal sdist ` instead of
building ` ./Setup ` .
Unlike ` haskell . lib . buildFromSdist ` , this does not require any dependencies
to be present . This makes ` buildFromCabalSdist ` faster than ` haskell . lib . buildFromSdist ` .
* /
buildFromCabalSdist = pkg :
haskellLib . overrideSrc
{
src = self . cabalSdist { inherit ( pkg ) src ; } ;
version = pkg . version ;
}
pkg ;
2022-09-09 18:33:20 +00:00
/*
Modify a Haskell package to add shell completion scripts for the
given executables produced by it . These completion scripts will be
picked up automatically if the resulting derivation is installed ,
e . g . by ` nix-env - i ` .
This depends on the ` - - * - completion ` flag ` optparse-applicative ` provides
automatically . Since we need to invoke installed executables , completions
are not generated if we are cross-compiling .
commands : names of the executables built by the derivation
pkg : Haskell package that builds the executables
Example :
generateOptparseApplicativeCompletions [ " e x e c 1 " " e x e c 2 " ] pkg
Type : [ str ] -> drv -> drv
* /
generateOptparseApplicativeCompletions =
self . callPackage (
{ stdenv }:
commands :
pkg :
if stdenv . buildPlatform . canExecute stdenv . hostPlatform
then lib . foldr haskellLib . __generateOptparseApplicativeCompletion pkg commands
else pkg
) { } ;
2017-04-12 17:28:06 +00:00
}