innerMerge: Handle empty definition lists after discharging properties

This allows specifying configuration that should be merged in with some
or all elements of a container option (e.g. listOf, attrsOf) without
needing to know whether those elements are actually defined elsewhere.

For example, this will default the fsType of all filesystems except
/boot to btrfs (and leaves /boot alone):

    fileSystems = mkMap (name: mkIf (name != "/boot") {
      fsType = mkDefault "btrfs";
    });

mkMap takes a function which takes an index of an element and returns a
value to be merged in with the other definitions for that element. For
sets, the index is just the attribute name. For lists, the mkMap
function is passed two arguments: The index of the relevant definition
in the list of all definitions for that option, and the index of the
element within that definition.

lib/modules.nix

@@ -106,12 +106,9 @@ rec {
               else []
             ) configs);
           nrOptions = count (m: isOption m.options) decls;
-          # Process mkMerge and mkIf properties.
-          defns' = concatMap (m:
-            if hasAttr name m.config
-              then map (m': { inherit (m) file; value = m'; }) (dischargeProperties (getAttr name m.config))
-              else []
-            ) configs;
+          # Extract the definitions for this loc
+          defns' = map (m: { inherit (m) file; value = getAttr name m.config; })
+            (filter (m: hasAttr name m.config) configs);
         in
           if nrOptions == length decls then
             let opt = fixupOptionType loc (mergeOptionDecls loc decls);
@@ -153,32 +150,46 @@ rec {
      config value. */
   evalOptionValue = loc: opt: defs:
     let
-      # Process mkOverride properties, adding in the default
-      # value specified in the option declaration (if any).
-      defsFinal = filterOverrides
-        ((if opt ? default then [{ file = head opt.declarations; value = mkOptionDefault opt.default; }] else []) ++ defs);
-      files = map (def: def.file) defsFinal;
-      # Type-check the remaining definitions, and merge them if
-      # possible.
+      # Add in the default value specified in the option declaration
+      defsWithDefault = (optional (opt ? default)
+        { file = head opt.declarations; value = mkOptionDefault opt.default; }) ++ defs;
+      inherit (mergeDefinitions loc opt.type defsWithDefault) defsFinal mergedValue;
       merged =
         if defsFinal == [] then
           throw "The option `${showOption loc}' is used but not defined."
         else
-          fold (def: res:
-            if opt.type.check def.value then res
-            else throw "The option value `${showOption loc}' in `${def.file}' is not a ${opt.type.name}.")
-            (opt.type.merge loc defsFinal) defsFinal;
+          mergedValue;
       # Finally, apply the ‘apply’ function to the merged
       # value.  This allows options to yield a value computed
       # from the definitions.
       value = (opt.apply or id) merged;
     in opt //
       { value = addErrorContext "while evaluating the option `${showOption loc}':" value;
+        # Note that definitions may contain undischarged mkMap properties,
+        # as mkMap can only be discharged in the merge function of the
+        # relevant (mappable) type.
         definitions = map (def: def.value) defsFinal;
         isDefined = defsFinal != [];
-        inherit files;
+        files = map (def: def.file) defsFinal;
       };
 
+  # Merge definitions of a value of a given type
+  mergeDefinitions = loc: type: defs: rec {
+      # Process mkOverride, mkIf, and mkMerge properties
+      defsFinal = filterOverrides (concatMap (m:
+        map (value: { inherit (m) file; inherit value; }) (dischargeProperties m.value)
+      ) defs);
+
+      # Merge everything, but check that types match first
+      mergedValue = fold (def: res:
+        if def.value._type or "" == "map"
+          then if type.mappable then res
+            else throw "Option value `${showOption loc}' in `${def.file}' is a mkMap but ${type.name} is not mappable"
+          else if type.check def.value then res
+            else throw "The option value `${showOption loc}' in `${def.file}' is not a ${type.name}."
+      ) (type.merge loc defsFinal) defsFinal;
+  };
+
   /* Given a config set, expand mkMerge properties, and push down the
      mkIf properties into the children.  The result is a list of
      config sets that do not have properties at top-level.  For
@@ -302,6 +313,16 @@ rec {
 
   mkFixStrictness = id; # obsolete, no-op
 
+  # Map a function, which takes an index ((defnNum, index) for lists, attrname
+  # for sets, etc) and returns a value to be merged with the other values
+  # defined for that index, over a collection. This can for example be used to
+  # apply some config to *every* submodule in an attrsOf submodule without
+  # needing to know which attrs are actually defined elsewhere
+  mkMap = f:
+    { _type = "map";
+      inherit f;
+    };
+
   # FIXME: Add mkOrder back in. It's not currently used anywhere in
   # NixOS, but it should be useful.
 

lib/types.nix

@@ -7,7 +7,13 @@ with import ./options.nix;
 with import ./trivial.nix;
 with import ./strings.nix;
 
-rec {
+let
+  inherit (import ./modules.nix) mergeDefinitions evalModules;
+
+  innerMerge = loc: type: defs: let
+    inherit (mergeDefinitions loc type defs) mergedValue defsFinal;
+  in if defsFinal == [] then {} else { value = mergedValue; };
+in rec {
 
   isType = type: x: (x._type or "") == type;
 
@@ -33,9 +39,11 @@ rec {
     , # Return a flat list of sub-options.  Used to generate
       # documentation.
       getSubOptions ? prefix: {}
+    , # A mappable type can handle mkMap defs when merging
+      mappable ? false
     }:
     { _type = "option-type";
-      inherit name check merge getSubOptions;
+      inherit name check merge getSubOptions mappable;
     };
 
 
@@ -104,23 +112,48 @@ rec {
 
     listOf = elemType: mkOptionType {
       name = "list of ${elemType.name}s";
-      check = value: isList value && all elemType.check value;
+      check = isList;
       merge = loc: defs:
-        concatLists (imap (n: def: imap (m: def':
-          elemType.merge (loc ++ ["[${toString n}-${toString m}]"])
-            [{ inherit (def) file; value = def'; }]) def.value) defs);
+        let
+          nonMaps = filter (d: d.value._type or "" != "map") defs;
+          maps = filter (d: d.value._type or "" == "map") defs;
+          mapResults = fold (m: imap (x: l: imap (y: l: l ++ [ {
+            inherit (m) file;
+            value = m.value.f x y;
+          } ]) l))
+            (map (d: map (x: []) d.value) nonMaps) maps;
+        in map (getAttr "value") (filter (hasAttr "value") (
+          concatLists (imap (n: def: imap (m: def':
+            innerMerge (loc ++ ["[${toString n}-${toString m}]"]) elemType
+              ([{ inherit (def) file; value = def'; }] ++ elemAt (elemAt mapResults (n - 1)) (m - 1))
+          ) def.value) nonMaps)
+        ));
       getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["*"]);
+      mappable = true;
     };
 
     attrsOf = elemType: mkOptionType {
       name = "attribute set of ${elemType.name}s";
-      check = x: isAttrs x && all elemType.check (attrValues x);
+      check = isAttrs;
       merge = loc: defs:
-        zipAttrsWith (name: elemType.merge (loc ++ [name]))
-          # Push down position info.
-          (map (def: listToAttrs (mapAttrsToList (n: def':
-            { name = n; value = { inherit (def) file; value = def'; }; }) def.value)) defs);
+        let
+          nonMaps = filter (d: d.value._type or "" != "map") defs;
+          maps = filter (d: d.value._type or "" == "map") defs;
+          names = concatMap (d: attrNames d.value) nonMaps;
+          mapResults = listToAttrs (map (name: {
+            inherit name;
+            value = map (m: { inherit (m) file; value = m.value.f name; }) maps;
+          }) names);
+        in mapAttrs (n: getAttr "value") (filterAttrs (n: hasAttr "value") (
+          zipAttrsWith (name: defs:
+            innerMerge (loc ++ [name]) elemType (defs ++ getAttr name mapResults)
+          )
+            # Push down position info.
+            (map (def: listToAttrs (mapAttrsToList (n: def':
+              { name = n; value = { inherit (def) file; value = def'; }; }) def.value)) nonMaps)
+        ));
       getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name>"]);
+      mappable = true;
     };
 
     # List or attribute set of ...
@@ -141,12 +174,11 @@ rec {
         attrOnly = attrsOf elemType;
       in mkOptionType {
         name = "list or attribute set of ${elemType.name}s";
-        check = x:
-          if isList x       then listOnly.check x
-          else if isAttrs x then attrOnly.check x
-          else false;
+        check = x: isList x || isAttrs x;
         merge = loc: defs: attrOnly.merge loc (imap convertIfList defs);
         getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name?>"]);
+        # maps over the post-convertifList defs
+        mappable = true;
       };
 
     uniq = elemType: mkOptionType {
@@ -170,15 +202,17 @@ rec {
     functionTo = elemType: mkOptionType {
       name = "function that evaluates to a(n) ${elemType.name}";
       check = isFunction;
-      merge = loc: defs:
-        fnArgs: elemType.merge loc (map (fn: { inherit (fn) file; value = fn.value fnArgs; }) defs);
+      merge = loc: defs: fnArgs:
+        (innerMerge loc elemType (map (fn:
+          { inherit (fn) file; value = fn.value fnArgs; }
+        ) defs)).value or (throw
+          "The option `${showOption loc}' is defined as a function that doesn't return any value (using mkIf or mkMerge), in ${showFiles (getFiles defs)}");
       getSubOptions = elemType.getSubOptions;
     };
 
     submodule = opts:
       let
         opts' = toList opts;
-        inherit (import ./modules.nix) evalModules;
       in
       mkOptionType rec {
         name = "submodule";