Use mkmerge for the all component. [Fixes #42]

Author: ElvishJerricco

lib/default.nix

@@ -13,49 +13,22 @@ with haskellLib;
     "benchmarks"
   ];
 
-  mergeComponents = lib.zipAttrsWith (_: comps: lib.genAttrs [
-    "depends"
-    "libs"
-    "frameworks"
-    "pkgconfig"
-    "build-tools"
-  ] (n: {
-    ${n} = lib.concatMap (comp: comp.${n} or []) comps;
-  }));
-
-  unionrAttrs = lib.foldr (a: b: a // b) {};
-
-  mergeConfigs = configs:
-    let
-      mergeComponentType = type: mergeComponents (map (conf: (conf.components or {}).${type} or {}) configs);
-    in unionrAttrs configs // {
-      flags = unionrAttrs (map (conf: conf.flags or {}) configs);
-      package = lib.foldr (conf: lib.recursiveUpdate (conf.package or {})) {} configs;
-      components =
-        mergeComponents (map (conf: removeAttrs (conf.components or {}) subComponentTypes) configs)
-        // lib.genAttrs subComponentTypes mergeComponentType;
-      configureFlags = concatMap (conf: conf.configureFlags or []) configs;
-    };
-
   foldrAttrVals = f: z: attrs:
-    lib.foldr (g: acc: g acc) z (lib.mapAttrsToList f attrs);
-
-  attrLength = attrs: builtins.length (builtins.attrValues attrs);
+    lib.foldr (g: acc: g acc) z (lib.mapAttrsToList (_name: f) attrs);
 
   foldComponents = tys: f: z: conf:
     let
       comps = conf.components or {};
-      foldSection = foldrAttrVals f;
-      libComp = acc:
-        foldSection acc
-          (removeAttrs comps subComponentTypes);
+      libComp = acc: if comps ? library then f comps.library acc else acc;
       subComps = acc:
         lib.foldr
-          (ty: acc': foldSection acc' (comps.${ty} or {}))
+          (ty: acc': foldrAttrVals f acc' (comps.${ty} or {}))
           acc
           tys;
     in libComp (subComps z);
 
+  getAllComponents = foldComponents subComponentTypes (c: acc: [c] ++ acc) [];
+
   componentPrefix = {
     # Are all of these right?
     sublibs = "sublib";

modules/package.nix

@@ -13,14 +13,12 @@
 #    tests = { "..." = { depends = ... }; ... };
 #  };
 
-{ lib, config, pkgs, ... }:
+{ lib, config, pkgs, haskellLib, ... }:
 
 with lib;
 with types;
 
 let
-  haskellLib = let hl = import ../lib { inherit lib; haskellLib = hl; }; in hl;
-
   # This is just like listOf, except that it filters out all null elements.
   listOfFilteringNulls = elemType: listOf elemType // {
     # Mostly copied from nixpkgs/lib/types.nix
@@ -175,17 +173,9 @@ in {
         type = attrsOf (componentType {});
         default = {};
       };
-      all = let
-        subComponentsDepends = sub: concatLists
-            (mapAttrsToList (_: c: c.depends or []) config.components.${sub} or {});
-        default = {
-          depends = config.components.library.depends ++
-            concatMap subComponentsDepends haskellLib.subComponentTypes;
-        };
-      in mkOption {
-        type = componentType default;
-        inherit default;
-        defaultText = "The merged dependencies of all other components";
+      all = mkOption {
+        type = componentType {};
+        description = "The merged dependencies of all other components";
       };
     };
 
@@ -289,4 +279,6 @@ in {
       default = false;
     };
   };
+
+  config.components.all = lib.mkMerge (haskellLib.getAllComponents config);
 }

modules/plan.nix

@@ -10,7 +10,7 @@
 #                packages = { "bytestring" = "a.b.c.d"; ... }; };
 # }
 
-{ lib, config, pkgs, pkgconfPkgs, ... }:
+{ lib, config, pkgs, pkgconfPkgs, haskellLib, ... }:
 
 with lib;
 with types;
@@ -21,7 +21,7 @@ with types;
       type = attrsOf (submodule {
         imports = [./package.nix];
         _module.args = {
-          inherit pkgs pkgconfPkgs;
+          inherit pkgs pkgconfPkgs haskellLib;
           inherit (config) hsPkgs;
           inherit (config.cabal) system compiler;
         };