commit 74f5fe50681003f075bf0b1ff811d0c0cd7c64f3 · pyrox.dev/nixpkgs

+2 -2

pkgs/development/haskell-modules/configuration-common.nix

···

       9
       9
        
       #

     

       10
       10
        
       # See comment at the top of configuration-nix.nix for more information about this

     

       11
       11
        
       # distinction.

     

       12
       12
       -
       { pkgs }:

     

       12
       12
       +
       { pkgs, haskellLib }:

     

       13
       13
        
       

     

       14
       14
       -
       with import ./lib.nix { inherit pkgs; };

     

       14
       14
       +
       with haskellLib;

     

       15
       15
        
       

     

       16
       16
        
       self: super: {

     

       17
       17

+2 -2

pkgs/development/haskell-modules/configuration-ghc-6.12.x.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-ghc-7.0.x.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-ghc-7.10.x.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-ghc-7.2.x.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-ghc-7.4.x.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-ghc-7.6.x.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-ghc-7.8.x.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-ghc-8.0.x.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-ghc-8.2.x.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-ghc-head.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-ghcjs.nix

···

       2
       2
        
       #

     

       3
       3
        
       # Please insert new packages *alphabetically*

     

       4
       4
        
       # in the OTHER PACKAGES section.

     

       5
       5
       -
       { pkgs }:

     

       5
       5
       +
       { pkgs, haskellLib }:

     

       6
       6
        
       

     

       7
       7
        
       let

     

       8
       8
        
         removeLibraryHaskellDepends = pnames: depends:

     

       9
       9
        
           builtins.filter (e: !(builtins.elem (e.pname or "") pnames)) depends;

     

       10
       10
        
       in

     

       11
       11
        
       

     

       12
       12
       -
       with import ./lib.nix { inherit pkgs; };

     

       12
       12
       +
       with haskellLib;

     

       13
       13
        
       

     

       14
       14
        
       self: super:

     

       15
       15

+2 -2

pkgs/development/haskell-modules/configuration-halvm-2.4.0.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
        
       

     

       3
       3
       -
       with import ./lib.nix { inherit pkgs; };

     

       3
       3
       +
       with haskellLib;

     

       4
       4
        
       

     

       5
       5
        
       self: super: {

     

       6
       6

+2 -2

pkgs/development/haskell-modules/configuration-nix.nix

···

       25
       25
        
       # * enabling/disabling certain features in packages

     

       26
       26
        
       #

     

       27
       27
        
       # If you have an override of this kind, see configuration-common.nix instead.

     

       28
       28
       -
       { pkgs }:

     

       28
       28
       +
       { pkgs, haskellLib }:

     

       29
       29
        
       

     

       30
       30
       -
       with import ./lib.nix { inherit pkgs; };

     

       30
       30
       +
       with haskellLib;

     

       31
       31
        
       

     

       32
       32
        
       # All of the overrides in this set should look like:

     

       33
       33
        
       #

+7 -7

pkgs/development/haskell-modules/default.nix

···

       1
       1
       -
       { pkgs, stdenv, ghc, all-cabal-hashes

     

       1
       1
       +
       { pkgs, stdenv, lib, haskellLib, ghc, all-cabal-hashes

     

       2
       2
        
       , compilerConfig ? (self: super: {})

     

       3
       3
        
       , packageSetConfig ? (self: super: {})

     

       4
       4
        
       , overrides ? (self: super: {})

     
···

       9
       9
        
       

     

       10
       10
        
       let

     

       11
       11
        
       

     

       12
       12
       -
         inherit (stdenv.lib) extends makeExtensible;

     

       13
       13
       -
         inherit (import ./lib.nix { inherit pkgs; }) overrideCabal makePackageSet;

     

       12
       12
       +
         inherit (lib) extends makeExtensible;

     

       13
       13
       +
         inherit (haskellLib) overrideCabal makePackageSet;

     

       14
       14
        
       

     

       15
       15
       -
         haskellPackages = makePackageSet {

     

       15
       15
       +
         haskellPackages = pkgs.callPackage makePackageSet {

     

       16
       16
        
           package-set = initialPackages;

     

       17
       17
       -
           inherit ghc extensible-self;

     

       17
       17
       +
           inherit stdenv haskellLib ghc extensible-self;

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         commonConfiguration = configurationCommon { inherit pkgs; };

     

       21
       21
       -
         nixConfiguration = configurationNix { inherit pkgs; };

     

       20
       20
       +
         commonConfiguration = configurationCommon { inherit pkgs haskellLib; };

     

       21
       21
       +
         nixConfiguration = configurationNix { inherit pkgs haskellLib; };

     

       22
       22
        
       

     

       23
       23
        
         extensible-self = makeExtensible

     

       24
       24
        
           (extends overrides

+9 -8

pkgs/development/haskell-modules/lib.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       # TODO(@Ericson2314): Remove `pkgs` param, which is only used for

     

       2
       2
       +
       # `buildStackProject` and `justStaticExecutables`

     

       3
       3
       +
       { pkgs, lib }:

     

       2
       4
        
       

     

       3
       5
        
       rec {

     

       4
       4
       -
         makePackageSet = pkgs.callPackage ./make-package-set.nix {};

     

       6
       6
       +
         makePackageSet = import ./make-package-set.nix;

     

       5
       7
        
       

     

       6
       8
        
         overrideCabal = drv: f: (drv.override (args: args // {

     

       7
       9
        
           mkDerivation = drv: (args.mkDerivation drv).override f;

     
···

       25
       27
        
         dontDistribute = drv: overrideCabal drv (drv: { hydraPlatforms = []; });

     

       26
       28
        
       

     

       27
       29
        
         appendConfigureFlag = drv: x: overrideCabal drv (drv: { configureFlags = (drv.configureFlags or []) ++ [x]; });

     

       28
       28
       -
         removeConfigureFlag = drv: x: overrideCabal drv (drv: { configureFlags = pkgs.stdenv.lib.remove x (drv.configureFlags or []); });

     

       30
       30
       +
         removeConfigureFlag = drv: x: overrideCabal drv (drv: { configureFlags = lib.remove x (drv.configureFlags or []); });

     

       29
       31
        
       

     

       30
       32
        
         addBuildTool = drv: x: addBuildTools drv [x];

     

       31
       33
        
         addBuildTools = drv: xs: overrideCabal drv (drv: { buildTools = (drv.buildTools or []) ++ xs; });

     
···

       71
       73
        
       

     

       72
       74
        
         disableHardening = drv: flags: overrideCabal drv (drv: { hardeningDisable = flags; });

     

       73
       75
        
       

     

       74
       74
       -
         sdistTarball = pkg: pkgs.lib.overrideDerivation pkg (drv: {

     

       76
       76
       +
         sdistTarball = pkg: lib.overrideDerivation pkg (drv: {

     

       75
       77
        
           name = "${drv.pname}-source-${drv.version}";

     

       76
       78
        
           buildPhase = "./Setup sdist";

     

       77
       79
        
           haddockPhase = ":";

     
···

       89
       91
        
           isLibrary = false;

     

       90
       92
        
           doHaddock = false;

     

       91
       93
        
           postFixup = "rm -rf $out/lib $out/nix-support $out/share/doc";

     

       92
       92
       -
         } // (if pkgs.stdenv.isDarwin then {

     

       94
       94
       +
         } // lib.optionalAttrs (pkgs.hostPlatform.isDarwin) {

     

       93
       95
        
           configureFlags = (drv.configureFlags or []) ++ ["--ghc-option=-optl=-dead_strip"];

     

       94
       94
       -
         } else {})

     

       95
       95
       -
         );

     

       96
       96
       +
         });

     

       96
       97
        
       

     

       97
       97
       -
         buildFromSdist = pkg: pkgs.lib.overrideDerivation pkg (drv: {

     

       98
       98
       +
         buildFromSdist = pkg: lib.overrideDerivation pkg (drv: {

     

       98
       99
        
           unpackPhase = let src = sdistTarball pkg; tarname = "${pkg.pname}-${pkg.version}"; in ''

     

       99
       100
        
             echo "Source tarball is at ${src}/${tarname}.tar.gz"

     

       100
       101
        
             tar xf ${src}/${tarname}.tar.gz

+22 -8

pkgs/development/haskell-modules/make-package-set.nix

···

       1
       1
        
       # This expression takes a file like `hackage-packages.nix` and constructs

     

       2
       2
        
       # a full package set out of that.

     

       3
       3
        
       

     

       4
       4
       -
       # required dependencies:

     

       5
       5
       -
       { pkgs, stdenv, all-cabal-hashes }:

     

       4
       4
       +
       { # package-set used for non-haskell dependencies (all of nixpkgs)

     

       5
       5
       +
         pkgs

     

       6
       6
        
       

     

       7
       7
       -
       # arguments:

     

       8
       8
       -
       #  * ghc package to use

     

       9
       9
       -
       #  * package-set: a function that takes { pkgs, stdenv, callPackage } as first arg and `self` as second

     

       10
       10
       -
       #  * extensible-self: the final, fully overriden package set usable with the nixpkgs fixpoint overriding functionality

     

       11
       11
       -
       { ghc, package-set, extensible-self }:

     

       7
       7
       +
       , # stdenv to use for building haskell packages

     

       8
       8
       +
         stdenv

     

       9
       9
       +
       

     

       10
       10
       +
       , haskellLib

     

       11
       11
       +
       

     

       12
       12
       +
       , # hashes for downloading Hackage packages

     

       13
       13
       +
         all-cabal-hashes

     

       14
       14
       +
       

     

       15
       15
       +
       , # compiler to use

     

       16
       16
       +
         ghc

     

       17
       17
       +
       

     

       18
       18
       +
       , # A function that takes `{ pkgs, stdenv, callPackage }` as the first arg and `self`

     

       19
       19
       +
         # as second, and returns a set of haskell packages

     

       20
       20
       +
         package-set

     

       21
       21
       +
       

     

       22
       22
       +
       , # The final, fully overriden package set usable with the nixpkgs fixpoint

     

       23
       23
       +
         # overriding functionality

     

       24
       24
       +
         extensible-self

     

       25
       25
       +
       }:

     

       12
       26
        
       

     

       13
       27
        
       # return value: a function from self to the package set

     

       14
       28
        
       self: let

     

       15
       29
        
       

     

       16
       30
        
         inherit (stdenv.lib) fix' extends makeOverridable;

     

       17
       17
       -
         inherit (import ./lib.nix { inherit pkgs; }) overrideCabal;

     

       31
       31
       +
         inherit (haskellLib) overrideCabal;

     

       18
       32
        
       

     

       19
       33
        
         mkDerivationImpl = pkgs.callPackage ./generic-builder.nix {

     

       20
       34
        
           inherit stdenv;

+2 -2

pkgs/development/tools/haskell/lambdabot/default.nix

···

       1
       1
       -
       { lib, haskell-lib, fetchpatch, makeWrapper, haskellPackages

     

       1
       1
       +
       { lib, haskellLib, fetchpatch, makeWrapper, haskellPackages

     

       2
       2
        
       , mueval

     

       3
       3
        
       , withDjinn ? true

     

       4
       4
        
       , aspell ? null

     
···

       25
       25
        
           modulesStr = lib.replaceChars ["\n"] [" "] modules;

     

       26
       26
        
           configStr = lib.replaceChars ["\n"] [" "] configuration;

     

       27
       27
        
       

     

       28
       28
       -
       in haskell-lib.overrideCabal haskellPackages.lambdabot (self: {

     

       28
       28
       +
       in haskellLib.overrideCabal haskellPackages.lambdabot (self: {

     

       29
       29
        
         patches = (self.patches or []) ++ [ ./custom-config.patch ];

     

       30
       30
        
         postPatch = (self.postPatch or "") + ''

     

       31
       31
        
           substituteInPlace src/Main.hs \

+1 -1

pkgs/top-level/all-packages.nix

···

       10085
       10085
        
         readosm = callPackage ../development/libraries/readosm { };

     

       10086
       10086
        
       

     

       10087
       10087
        
         lambdabot = callPackage ../development/tools/haskell/lambdabot {

     

       10088
       10088
       -
           haskell-lib = haskell.lib;

     

       10088
       10088
       +
           haskellLib = haskell.lib;

     

       10089
       10089
        
         };

     

       10090
       10090
        
       

     

       10091
       10091
        
         lambda-mod-zsh-theme = callPackage ../shells/lambda-mod-zsh-theme/default.nix { };

+27 -19

pkgs/top-level/haskell-packages.nix

···

       1
       1
       -
       { pkgs, callPackage, stdenv, buildPlatform, targetPlatform }:

     

       1
       1
       +
       { pkgs, lib, newScope, stdenv, buildPlatform, targetPlatform }:

     

       2
       2
        
       

     

       3
       3
       -
       let # These are attributes in compiler and packages that don't support integer-simple.

     

       4
       4
       -
           integerSimpleExcludes = [

     

       5
       5
       -
             "ghc6102Binary"

     

       6
       6
       -
             "ghc704Binary"

     

       7
       7
       -
             "ghc742Binary"

     

       8
       8
       -
             "ghc6104"

     

       9
       9
       -
             "ghc6123"

     

       10
       10
       -
             "ghc704"

     

       11
       11
       -
             "ghc763"

     

       12
       12
       -
             "ghcjs"

     

       13
       13
       -
             "ghcjsHEAD"

     

       14
       14
       -
             "ghcCross"

     

       15
       15
       -
             "jhc"

     

       16
       16
       -
             "uhc"

     

       17
       17
       -
             "integer-simple"

     

       18
       18
       -
           ];

     

       19
       19
       -
       in rec {

     

       3
       3
       +
       let

     

       4
       4
       +
         # These are attributes in compiler and packages that don't support integer-simple.

     

       5
       5
       +
         integerSimpleExcludes = [

     

       6
       6
       +
           "ghc6102Binary"

     

       7
       7
       +
           "ghc704Binary"

     

       8
       8
       +
           "ghc742Binary"

     

       9
       9
       +
           "ghc6104"

     

       10
       10
       +
           "ghc6123"

     

       11
       11
       +
           "ghc704"

     

       12
       12
       +
           "ghc763"

     

       13
       13
       +
           "ghcjs"

     

       14
       14
       +
           "ghcjsHEAD"

     

       15
       15
       +
           "ghcCross"

     

       16
       16
       +
           "jhc"

     

       17
       17
       +
           "uhc"

     

       18
       18
       +
           "integer-simple"

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         haskellLib = import ../development/haskell-modules/lib.nix {

     

       22
       22
       +
           inherit (pkgs) lib;

     

       23
       23
       +
           inherit pkgs;

     

       24
       24
       +
         };

     

       20
       25
        
       

     

       21
       21
       -
         lib = import ../development/haskell-modules/lib.nix { inherit pkgs; };

     

       26
       26
       +
         callPackage = newScope { inherit haskellLib; };

     

       27
       27
       +
       

     

       28
       28
       +
       in rec {

     

       29
       29
       +
         lib = haskellLib;

     

       22
       30
        
       

     

       23
       31
        
         compiler = {

     

       24
       32