14 Aug 2024 |
Matt Sturgeon | I also don't know how much time I can dedicate to it. I had looked at it before when exploring solutions to https://matrix.to/#/!wfudwzqQUiJYJnqfSY:nixos.org/$mVuETvj4dPJNF6ZUdVEVvWmp07L5G3X-6y0bk-NmCP4?via=nixos.org&via=matrix.org&via=nixos.dev, however I came to the conclusion it is an interesting (and useful looking) type, but not a viable solution to the problem we have in nixvim.
I'll attempt to clarify a little in my response to your (very helpful) feedback in #333799.
| 14:45:44 |
Robert Hensing (roberth) | ohh saw the OP but glossed over the matrix thread - well good to have the context in github as well I guess | 14:50:44 |
Matt Sturgeon | Don't blame you, it ended up being a long thread (as usual!) | 14:51:11 |
Matt Sturgeon | Thanks again Robert Hensing (roberth) for your feedback and for reminding me of your existing proposals!
I've posted my initial thoughts on github. And further;
Reading through your simple/minimal module eval proposal, I think that's a great solution provided defining config from outside the simple-module type looks the same as defining config for a submodule type; i.e. many of the features you mention arent supported (mkIf for instance) still work, but are handled in the "host" module system before evaluating the resulting configured modules.
Enforcing one module/option per attr level (i.e. no nested options) sounds like a reasonable simplification too.
My main concern is that "perfection" here may be acting as the enemy of "good"; i.e. your proposal is great, but will be much more effort to actually get merged into nixpkgs.
From a different perspective, there's also some simplicity in not reinventing the wheel here, just to support one small feature (config without undefined opts). While we could see this as an opportunity to design a better/faster system, we could also just use the small change for now and consider in the future how it can be improved/replaced. 🤔
| 15:19:50 |
Matt Sturgeon | Hm, I'm not sure why I was under the impression that the record type was restricted to being flat (and can't contain sub-options or sub-records, I guess). I assume the wildcard type could also be set to something like attrsOf anything to allow recursive merging?
If we can define nested optionalFields and recursively merged wildcards I think it fits nixvim's needs.
| 15:29:31 |
Matt Sturgeon | * Hm, I'm not sure why I was under the impression that the record type was restricted to being flat (and couldn't contain sub-options, sub-records, sub-fields?). I assume the wildcard type could also be set to something like attrsOf anything to allow recursive merging?
If we can define nested optionalFields and recursively merged wildcards I think it fits nixvim's needs.
| 15:30:22 |
Robert Hensing (roberth) | Yeah records can have any type in their fields, including other records. It's simpler, lazier and more efficient that way. | 16:28:23 |
nbp | I have no time this week, I might give it a look next week if needed. | 16:39:28 |
Matt Sturgeon | I'll play around with adding optionalFields to types.record , won't have anything "finished" today though. I believe after that it's just adding docs and getting reviews? | 16:42:06 |
Matt Sturgeon | I have a draft PR up based on Robert Hensing (roberth)'s prior work, seems to be working but haven't polished it up or thoroughly tested it yet. | 17:58:12 |
15 Aug 2024 |
mr-qubo | I'm using modules in my nixos config. For every user in my config I write something like this:
home-manager.users.alice = {
imports = [ ./hm-common ];
...
};
Is it possible to somehow extend home-manager.users. submodule so that it always includes my import, so I don't have to write it for every user?
| 21:51:03 |
Matt Sturgeon | If you just want to include hm-common for all users, have you considered home-manager's sharedModules option? | 22:15:46 |
nbp | mr-qubo: yes, by extending the option declaration.
{lib, ...}: {
home-manage.users = lib.mkOptions {
type = lib.types.attrsOf (lib.types.submodules [ ./hm-common ]);
};
}
| 22:26:32 |
nbp | * mr-qubo: yes, by extending the option declaration.
{lib, ...}: {
options.home-manage.users = lib.mkOptions {
type = lib.types.attrsOf (lib.types.submodules [ ./hm-common ]);
};
}
| 22:29:01 |
16 Aug 2024 |
SebTM | Hey, I'm trying to access pkgs.system in a nixosModule for "imports" to determinate if I want to load a certain module based on x86 or aarch64 - but it goes to infinite recursion encountered while when using it in e.g. options it works? (tested with builtins.trace)
| 07:44:07 |
Matt Sturgeon | pkgs is not fixed when evaluating imports, in fact nothing that depends on options or config is, including config._module.args.pkgs .
One approach would be to always load the module, but only enable its options on certain systems. | 12:24:53 |
Matt Sturgeon | Another approach would be to check system outside of the module eval. E.g. if you're using lib.evalModules you could do:
lib.evalModules {
modules = [
./common.nix
]
++ lib.optionals (system == "some-system") [
./system-specific.nix
];
}
(Same applies to wrappers, such as lib.nixosSystem ) | 14:26:54 |
17 Aug 2024 |
Matt Sturgeon | * Another approach would be to check system outside of the module eval. E.g. if you're using lib.evalModules you could do:
lib.evalModules {
modules = [
./common.nix
]
++ lib.optionals (system == "some-system") [
./system-specific.nix
];
}
(Same applies to wrappers, such as lib.nixosSystem )
SebTM
| 22:17:28 |
Matt Sturgeon | * SebTM
pkgs is not fixed when evaluating imports, in fact nothing that depends on options or config is, including config._module.args.pkgs .
One approach would be to always load the module, but only enable its options on certain systems.
| 22:17:41 |
Matt Sturgeon | * Another approach would be to check system outside of the module eval. E.g. if you're using lib.evalModules you could do:
lib.evalModules {
modules = [
./common.nix
]
++ lib.optionals (system == "some-system") [
./system-specific.nix
];
}
(Same applies to wrappers, such as lib.nixosSystem )
| 22:18:02 |
Matt Sturgeon | Anyone know why overriding an option-type's merge function seems to have no effect?
E.g. I have a submodule with a deprecated sub-option. Since the submodule's final value is often fully evaluated (e.g. printed to lua using lib.generators.toLua ) I'd like to filter the deprecated option out of the final-merged value to prevent "used but not defined" errors.
I figured I could do something like:
fooType =
let
sub = types.submodule ({ config, options, ... }: {
options.deprecatedOption = mkOption { };
};
in
sub // {
merge = loc: defs: builtins.removeAttrs (sub.merge loc defs) [
"deprecatedOption"
];
};
However this doesn't seem to have any effect, deprecatedOption is still present in fooType 's final value.
For this specific example, I could use an option's apply function, but I'd like to understand the underlying issue. Implementing it in the type would also be better, as I may use it in several options.
I had a the same issue a few weeks ago when extending types.coercedTo to support deprecation warnings. I wanted to just override the merge attr, however I ended up having to copy the entire coercedTo implementation to get it working...
Seeing as mkOptionType just returns an attrset, I'm confused why overriding the merge attr seemingly doesn't affect how the type is merged in the module system.
| 22:31:16 |
Matt Sturgeon | * Anyone know why overriding an option-type's merge function seems to have no effect?
E.g. I have a submodule with a deprecated sub-option. Since the submodule's final value is often fully evaluated (e.g. printed to lua using lib.generators.toLua ) I'd like to filter the deprecated option out of the final-merged value to prevent "used but not defined" errors.
I figured I could do something like:
fooType =
let
sub = types.submodule ({ config, options, ... }: {
options.deprecatedOption = mkOption { };
});
in
sub // {
merge = loc: defs: builtins.removeAttrs (sub.merge loc defs) [
"deprecatedOption"
];
};
However this doesn't seem to have any effect, deprecatedOption is still present in fooType 's final value.
For this specific example, I could use an option's apply function, but I'd like to understand the underlying issue. Implementing it in the type would also be better, as I may use it in several options.
I had a the same issue a few weeks ago when extending types.coercedTo to support deprecation warnings. I wanted to just override the merge attr, however I ended up having to copy the entire coercedTo implementation to get it working...
Seeing as mkOptionType just returns an attrset, I'm confused why overriding the merge attr seemingly doesn't affect how the type is merged in the module system.
| 22:32:23 |
Matt Sturgeon | * Anyone know why overriding an option-type's merge function seems to have no effect?
E.g. I have a submodule with a deprecated sub-option. Since the submodule's final value is often fully evaluated (e.g. printed to lua using lib.generators.toLua ) I'd like to filter the deprecated option out of the final-merged value to prevent "used but not defined" errors.
I figured I could do something like:
fooType =
let
sub = types.submodule ({ config, options, ... }: {
options.deprecatedOption = mkOption { };
});
in
sub // {
merge = loc: defs: builtins.removeAttrs (sub.merge loc defs) [
"deprecatedOption"
];
};
However this doesn't seem to have any effect, deprecatedOption is still present in fooType 's final value. Calling trace in the overridden merge function doesn't print anything either.
For this specific example, I could use an option's apply function, but I'd like to understand the underlying issue. Implementing it in the type would also be better, as I may use it in several options.
I had a the same issue a few weeks ago when extending types.coercedTo to support deprecation warnings. I wanted to just override the merge attr, however I ended up having to copy the entire coercedTo implementation to get it working...
Seeing as mkOptionType just returns an attrset, I'm confused why overriding the merge attr seemingly doesn't affect how the type is merged in the module system.
| 22:33:54 |
18 Aug 2024 |
SebTM | In reply to @mattsturg:matrix.org
Another approach would be to check system outside of the module eval. E.g. if you're using lib.evalModules you could do:
lib.evalModules {
modules = [
./common.nix
]
++ lib.optionals (system == "some-system") [
./system-specific.nix
];
}
(Same applies to wrappers, such as lib.nixosSystem )
Awesome thanks for explaining ✌🏻👌🏻🙏 | 07:38:58 |
| r3vx joined the room. | 14:18:31 |
22 Aug 2024 |
| Artur Manuel joined the room. | 13:04:02 |
| Artur Manuel changed their profile picture. | 14:52:58 |
23 Aug 2024 |
mr-qubo | I'm trying to write nixos config where I can set nixos options from home-manager modules. But I can't get around infinite recursion errors. I wrote this nixos module, I though this should work, but I'm still getting infinite recursion error, which I don't know how to debug.
{ lib, options, ... }:
with builtins; with lib;
let
hmModuleBase = with options.home-manager.users.type.nestedTypes.elemType.functor.payload; evalModules {
inherit class specialArgs;
modules = modules ++ [{
options.MrQubo = {
osConfigs = {
type = options.raw;
};
};
}];
};
evalHmModule = module:
hmModuleBase.extendModules { modules = [ module ]; };
isImportableNV = { name, value }:
(value == "regular" && match ".*\\.nix" name != null) || (value == "directory" && (readDir "${localOverlays}/${name}") ? "default.nix");
parseNV = { name, value }: rec {
username = removeSuffix ".nix" name;
module = evalHmModule ../users/${name};
};
userModules = map parseNV (filter isImportableNV (attrsToList (readDir ../users)));
osConfigs = flatten (map (attrs: attrs.module.MrQubo.osConfigs) userModules);
hmUsersConfig = {
home-manager.users = listToAttrs (map (attrs: { name = attrs.username; value = attrs.module; }) userModules);
};
in mkMerge (osConfigs ++ [ hmUsersConfig ])
| 13:15:22 |
25 Aug 2024 |
Matt Sturgeon | Robert Hensing (roberth) thanks for your thoughts here, I figured I'd reply here to save derailing that PR's discussion 😁
I just had a quick look in the repl, and highestPrio seems to be 1500 when an option is undefined such that it is using it's default value.
So we could have an isOptionDefault , but it wouldn't be able to distinguish between a default passed to mkOption and a config definition wrapped using mkOptionDefault .
Maybe that'd be the intended behavior though? 🤔
This also begs the question of how an override priority above 1500 should be handled, though I guess that's off-topic!
| 14:53:57 |
Matt Sturgeon | * Robert Hensing (roberth) thanks for your thoughts here, I figured I'd reply here to save derailing that PR's discussion 😁
An isDefinedExplicitly option attr, true when isDefined , but without using the default .
This can also be achieved with a function from option to bool, by looking at the highestPrio attribute.
I just had a quick look in the repl, and highestPrio seems to be 1500 when an option is undefined such that it is using it's default value.
So we could have an isOptionDefault , but it wouldn't be able to distinguish between a default passed to mkOption and a config definition wrapped using mkOptionDefault .
Maybe that'd be the intended behavior though? 🤔
This also begs the question of how an override priority above 1500 should be handled, though I guess that's off-topic!
| 14:54:18 |