[exploratory] Module system types.record, types.fix

lib/default.nix

@@ -84,7 +84,7 @@ let
       mapAttrs' mapAttrsToList concatMapAttrs mapAttrsRecursive mapAttrsRecursiveCond
       genAttrs isDerivation toDerivation optionalAttrs
       zipAttrsWithNames zipAttrsWith zipAttrs recursiveUpdateUntil
-      recursiveUpdate matchAttrs overrideExisting showAttrPath getOutput getBin
+      recursiveUpdate removeAttrs matchAttrs overrideExisting showAttrPath getOutput getBin
       getLib getDev getMan chooseDevOutputs zipWithNames zip
       recurseIntoAttrs dontRecurseIntoAttrs cartesianProductOfSets
       updateManyAttrsByPath;

lib/tests/modules.sh

@@ -64,6 +64,33 @@ checkConfigError() {
     fi
 }
 
+# record field
+checkConfigOutput '^"Alice"$' config.people.alice.name ./declare-record.nix ./define-record-alice.nix ./define-record-bob.nix
+checkConfigOutput '^2019$' config.people.bob.nixerSince ./declare-record.nix ./define-record-alice.nix ./define-record-bob.nix
+
+# record field type error
+checkConfigError 'A definition for option .people.mallory.nixerSince. is not of type .signed integer.. Definition values' config.people.mallory.nixerSince ./declare-record.nix ./define-record-mallory.nix
+checkConfigError 'define-record-mallory.nix.: "beginning of time"' config.people.mallory.nixerSince ./declare-record.nix ./define-record-mallory.nix
+
+# record field default
+checkConfigOutput '^true$' config.people.bob.isCool ./declare-record.nix ./define-record-alice.nix ./define-record-bob.nix
+
+# record field bad default definition
+checkConfigError 'In .the default value of option people.mallory.: "yeah"' config.people.mallory.isCool ./declare-record-bad-default.nix ./define-record-mallory.nix
+checkConfigError 'A definition for option .people.mallory.isCool. is not of type .boolean.. Definition values:' config.people.mallory.isCool ./declare-record-bad-default.nix ./define-record-mallory.nix
+
+# record field works in presence of wildcard
+checkConfigOutput '^2016$' config.people.alice.nixerSince ./declare-record-wildcard.nix ./define-record-alice-prefs.nix
+
+# record wildcard field
+checkConfigOutput '^true$' config.people.alice.mechKeyboard ./declare-record-wildcard.nix ./define-record-alice-prefs.nix
+
+
+# fix
+checkConfigOutput '"bobby"' config.people.lilbob.name ./fixpoint.nix
+
+if false; then
+
 # Shorthand meta attribute does not duplicate the config
 checkConfigOutput '^"one two"$' config.result ./shorthand-meta.nix
 
@@ -462,6 +489,8 @@ checkConfigOutput '^34|23$' options.submoduleLine34.declarationPositions.1.line
 # nested options work
 checkConfigOutput '^30$' options.nested.nestedLine30.declarationPositions.0.line ./declaration-positions.nix
 
+fi
+
 cat <<EOF
 ====== module tests ======
 $pass Pass

lib/tests/modules/declare-record-bad-default.nix

@@ -0,0 +1,25 @@
+{ lib, ... }:
+
+let
+  inherit (lib) mkOption types;
+
+  person = types.record {
+    fields = {
+      nixerSince = mkOption {
+        type = types.int;
+      };
+      name = mkOption {
+        type = types.str;
+      };
+      isCool = mkOption {
+        type = types.bool;
+        default = "yeah";
+      };
+    };
+  };
+
+in {
+  options.people = mkOption {
+    type = types.attrsOf person;
+  };
+}

lib/tests/modules/declare-record-wildcard.nix

@@ -0,0 +1,24 @@
+{ lib, ... }:
+
+let
+  inherit (lib) mkOption types;
+
+  person = types.record {
+    fields = {
+      nixerSince = mkOption {
+        type = types.int;
+      };
+      name = mkOption {
+        type = types.str;
+      };
+    };
+    wildcard = mkOption {
+      type = types.bool;
+    };
+  };
+
+in {
+  options.people = mkOption {
+    type = types.attrsOf person;
+  };
+}

lib/tests/modules/declare-record.nix

@@ -0,0 +1,25 @@
+{ lib, ... }:
+
+let
+  inherit (lib) mkOption types;
+
+  person = types.record {
+    fields = {
+      nixerSince = mkOption {
+        type = types.int;
+      };
+      name = mkOption {
+        type = types.str;
+      };
+      isCool = mkOption {
+        type = types.bool;
+        default = true;
+      };
+    };
+  };
+
+in {
+  options.people = mkOption {
+    type = types.attrsOf person;
+  };
+}

lib/tests/modules/define-record-alice-prefs.nix

@@ -0,0 +1,9 @@
+{ lib, ... }: {
+  people.alice = {
+    nixerSince = 2016;
+    name = "Alice";
+    hiRes = true;
+    mechKeyboard = true;
+    spiders = false;
+  };
+}

lib/tests/modules/define-record-alice.nix

@@ -0,0 +1,6 @@
+{
+  people.alice = {
+    nixerSince = 2016;
+    name = "Alice";
+  };
+}

lib/tests/modules/define-record-bob.nix

@@ -0,0 +1,6 @@
+{
+  people.bob = {
+    nixerSince = 2019;
+    name = "Bob";
+  };
+}

lib/tests/modules/define-record-mallory.nix

@@ -0,0 +1,6 @@
+{
+  people.mallory = {
+    nixerSince = "beginning of time";
+    name = "Bobby";
+  };
+}

lib/tests/modules/fixpoint.nix

@@ -0,0 +1,27 @@
+{ lib, ... }:
+let
+  inherit (lib) types mkOption;
+
+  person = types.record {
+    fields = {
+      name = mkOption { type = lib.types.str; };
+      age = mkOption { type = lib.types.int; };
+    };
+  };
+
+  bobber = { value }: {
+    name = if value.age < 10 then "bobby" else "bob";
+  };
+in
+{
+  options = {
+    people = mkOption {
+      type = types.attrsOf (types.fix person);
+      default = {};
+    };
+  };
+  config = {
+    people.bob = lib.mkMerge [ { age = 23; } bobber ];
+    people.lilbob = lib.mkMerge [ { age = 3; } bobber ];
+  };
+}

lib/types.nix

@@ -913,7 +913,9 @@ rec {
     # Augment the given type with an additional type check function.
     addCheck = elemType: check: elemType // { check = x: elemType.check x && check x; };
 
-  };
+  }
+  // import ./types/fix.nix { inherit lib; }
+  // import ./types/record.nix { inherit lib; };
 };
 
 in outer_types // outer_types.types

lib/types/fix.nix

@@ -0,0 +1,29 @@
+{ lib }:
+
+let
+  inherit (lib) toFunction mkOptionType
+    optionDescriptionPhrase isFunction mergeDefinitions defaultFunctor;
+
+  # TODO: should this be a type or a "property"? (i.e. one of `mkIf`, `mkMerge`, etc)
+  fix = t: mkOptionType {
+    name = "fixpoint of ${t.name}";
+    description = t.description;
+    descriptionClass = "composite";
+    check = v: isFunction v || t.check v;
+    merge = loc: defs:
+      let
+        # TODO: facilities elsewhere for wiring `options` and/or other "meta" info into this.
+        args = { value = r; };
+        r = (mergeDefinitions loc t (map (fn: { inherit (fn) file; value = toFunction fn.value args; }) defs)).mergedValue;
+      in r;
+    getSubOptions = prefix: t.getSubOptions prefix;
+    getSubModules = t.getSubModules;
+    substSubModules = m: fix (t.substSubModules m);
+    functor = defaultFunctor "fix" // { inherit t; };
+    nestedTypes.t = t;
+  };
+
+in
+{
+  inherit fix;
+}

lib/types/record.nix

@@ -0,0 +1,86 @@
+{ lib }:
+
+let
+  inherit (lib)
+    mapAttrs zipAttrsWith removeAttrs attrNames showOption
+    mergeDefinitions mkOptionType isAttrs
+    ;
+
+  record = args@{ fields, wildcard ? null }:
+    let
+      fields =
+        mapAttrs
+          (name: value: 
+            if value._type or null != "option"
+            then throw "Record field `${lib.escapeNixIdentifier name}` must be declared with `mkOption`."
+            else if value?apply then throw "In field ${lib.escapeNixIdentifier name} records do not support options with `apply`"
+            else if value?readOnly then throw "In field ${lib.escapeNixIdentifier name} records do not support options with `readOnly`"
+            else value)
+          args.fields;
+      wildcard =
+        if args.wildcard or null == null
+        then null
+        else if args.wildcard._type or null != "option"
+        then throw "Record wildcard must be declared with `mkOption`."
+        else if args.wildcard?apply
+        then throw "Records do not support options with `apply`, but wildcard has `apply`."
+        else args.wildcard;
+    in
+    mkOptionType {
+      name = "record";
+      description = if wildcard == null then "record" else "open record of ${wildcard.description}";
+      descriptionClass = if wildcard == null then "noun" else "composite";
+      check = isAttrs;
+      merge = loc: defs:
+        let
+          data = zipAttrsWith
+            (name: values: values)
+            (map
+              (def: mapAttrs (_fieldName: fieldValue: { inherit (def) file; value = fieldValue; }) def.value)
+              defs);
+          requiredFieldValues =
+            mapAttrs
+              (fieldName: fieldOption:
+                builtins.addErrorContext ("while evaluating the field `${fieldName}' of option `${showOption loc}'") (
+                  (mergeDefinitions
+                    (loc ++ [fieldName])
+                    fieldOption.type
+                    (data.${fieldName} or [] ++
+                      (if fieldOption?default
+                      then [{ value = fieldOption.default; file = "the default value of option ${showOption loc}"; }]
+                      else []))
+                  ).mergedValue
+                )
+              )
+              fields;
+          extraData = removeAttrs data (attrNames fields);
+        in
+          if wildcard == null
+          then
+            if extraData == {}
+            then requiredFieldValues
+            else throw "A definition for option `${showOption loc}' has an unknown field."
+          else
+            requiredFieldValues //
+              mapAttrs
+                (fieldName: fieldDefs:
+                  builtins.addErrorContext ("while evaluating the wildcard field `${fieldName}' of option `${showOption loc}'") (
+                    (mergeDefinitions
+                      (loc ++ [fieldName])
+                      wildcard.type
+                      fieldDefs
+                    ).mergedValue
+                  )
+                )
+                extraData;
+      nestedTypes = fields // {
+        # potential collision with `_wildcard` field
+        _wildcard = wildcard;
+      };
+    };
+
+in
+# public
+{
+  inherit record;
+}