Wow! @arcnmx asked why setting _module.args.bar = throw "Bar evaluated!" would throw even when bar wasn't supposed to be evaluated. Here's a reproducible example:

with import <nixpkgs/lib>;
(evalModules {
  modules = [
    ({ foo, bar, ... }: {
      config._module.args = {
        foo = "Value of foo";
        bar = throw "Bar evaluated!";
      };
    })
  ];
}).config._module.args.foo

Well turns out args is defined as an attrsOf! With lazyAttrsOf this is no problem anymore, and I think this can be the first justified use of lazyAttrsOf in nixpkgs (especially since it doesn't make sense to have mkIf false on such a value).

Nice, that would replace our https://github.com/hercules-ci/nix-pre-commit-hooks/blob/master/nix/lazyAttrsOf.nix

@roberth After thinking about it for a while, what you suggested with a default value sounds like a good idea. Because how this PR is now, there's no way to recover from a mkIf false, since the.option ? foo returns true but accessing it errors. I think we could do with a much simpler interface though, even going as far as using null as that special value without being able to customize it. Because I think all such attrsOf-like options should allow unsetting keys with null, so there one shouldn't need to distinguish between null and mkIf false. This however also implies that the given elemType needs to be nullOr, which leads to this nicely sounding type:

let {
  nullableAttrsOf = elemType:
    /* Implementation behaves like `lazyAttrsOf (nullOr elemType)`
       description could be `attribute set of (null for unset or elemType)`
    */;
}

This would work really well for NixOS/rfcs#42 too. What do you think of this?

@roberth I updated the code with your suggestion. I've decided to use emptyValue to represent such an empty value, since placeholder is already a builtin nix function name, and it really represents an empty value. See commit df5478f. I updated the tests and the documentation on this too. Let me know if this looks good to you

Rebased to fix conflicts

@roberth Applied your first 2 suggestions

I noticed that I didn't implement type merging, so I did that now. E.g. this now works (foo.one.bar can be evaluated without an exception):

{ config, lib, pkgs, ... }: {

  imports = [
    {
      options.foo = lib.mkOption {
        type = lib.types.lazyAttrsOf (lib.types.submodule {
          options.bar = lib.mkOption {
            default = false;
          };
        });
      };
    }
    {
      options.foo = lib.mkOption {
        type = lib.types.lazyAttrsOf (lib.types.submodule {
          options.baz = lib.mkOption {
            default = false;
          };
        });
      };
    }
  ];

  config = {
    boot.loader.grub.device = "nodev";
    fileSystems."/".device = "x";

    foo = {
      one.bar = true;
      two = throw "nothing";
    };
  };
}

Using attrsOf elemType // wasn't worth it anymore, and it also didn't seem to harmonize with type merging well at all, so I'm just declaring all attributes separately in lazyAttrsOf.

Rebased to fix conflicts, will merge after ofborg is happy

This pull request has been mentioned on NixOS Discourse. There might be relevant details there:

https://discourse.nixos.org/t/january-2020-in-nixos/5771/1