perf(core): Hyperfine benchmark and perf improvements

nix/ctx-apply.nix

@@ -2,19 +2,19 @@
 let
   inherit (den.lib) parametric;
 
-  cleanCtx =
-    self:
-    builtins.removeAttrs self [
-      "name"
-      "description"
-      "into"
-      "provides"
-      "__functor"
-      "modules"
-      "resolve"
-      "_module"
-      "_"
-    ];
+  ctxKeys = [
+    "name"
+    "description"
+    "into"
+    "provides"
+    "__functor"
+    "modules"
+    "resolve"
+    "_module"
+    "_"
+  ];
+
+  cleanCtx = self: builtins.removeAttrs self ctxKeys;
 
   transformAll =
     source: self: ctx:
@@ -41,13 +41,7 @@ let
 
   noop = _: { };
 
-  crossProvider =
-    p:
-    let
-      src = p.source;
-      name = p.ctxDef.name;
-    in
-    if src == null then noop else src.provides.${name} or noop;
+  crossProvider = p: if p.source == null then noop else p.source.provides.${p.ctxDef.name} or noop;
 
   dedupIncludes =
     let

nix/fn-can-take.nix

@@ -4,15 +4,11 @@ let
     params: func:
     let
       givenFn = builtins.isFunction func || (builtins.isAttrs func && func ? __functor);
-      givenArgs = builtins.isAttrs params;
       fargs = lib.functionArgs func;
-      provided = builtins.attrNames params;
-      args = lib.mapAttrsToList (name: optional: { inherit name optional; }) fargs;
-      required = map (x: x.name) (lib.filter (x: !x.optional) args);
-      intersection = lib.intersectLists required provided;
-      satisfied = givenFn && givenArgs && lib.length required == lib.length intersection;
-      noExtras = lib.length required == lib.length provided;
-      exactly = satisfied && noExtras;
+      required = lib.filterAttrs (_: optional: !optional) fargs;
+      reqNames = builtins.attrNames required;
+      satisfied = givenFn && builtins.isAttrs params && builtins.all (n: params ? ${n}) reqNames;
+      exactly = satisfied && builtins.length reqNames == builtins.length (builtins.attrNames params);
     in
     {
       inherit satisfied exactly;

nix/types.nix

@@ -220,9 +220,8 @@ let
     from: intent: name:
     let
       asp = intent { ${name} = from; };
-      mod = asp.resolve { inherit (from) class; };
     in
-    mod;
+    den.lib.aspects.resolve (from.class) [ ] asp;
 in
 {
   inherit hostsOption homesOption;

templates/ci/modules/features/deadbugs/dup-functors-issue-216.nix

@@ -21,7 +21,8 @@ let
         x = 0;
         y = 1;
       };
-      fooModule = fooAspect.resolve { class = "foo"; };
+      resolve = ev.config.den.lib.aspects.resolve;
+      fooModule = resolve "foo" [ ] fooAspect;
 
       namesModule.options.names = lib.mkOption { type = lib.types.listOf lib.types.str; };
       ev2 = lib.evalModules {

templates/ci/modules/features/perf/ctx-chain.nix

@@ -0,0 +1,92 @@
+{ denTest, lib, ... }:
+let
+  mkCtxModules =
+    n:
+    lib.genList (
+      i:
+      let
+        name = "ctx-${toString i}";
+        next = "ctx-${toString (i + 1)}";
+        base = {
+          description = name;
+          _.${name} =
+            { x }:
+            {
+              funny.names = [ "${name}-${x}" ];
+            };
+        };
+        withInto =
+          if i + 1 < n then
+            {
+              into.${next} = { x }: [ { x = "${x}+${toString i}"; } ];
+            }
+          else
+            { };
+      in
+      { den, ... }:
+      {
+        den.ctx.${name} = base // withInto;
+      }
+    ) n;
+in
+{
+  flake.tests.perf-ctx = {
+
+    test-ctx-chain-5 = denTest (
+      { den, funnyNames, ... }:
+      {
+        imports = mkCtxModules 5;
+        expr = builtins.length (funnyNames (den.ctx.ctx-0 { x = "v"; }));
+        expected = 5;
+      }
+    );
+
+    test-ctx-chain-10 = denTest (
+      { den, funnyNames, ... }:
+      {
+        imports = mkCtxModules 10;
+        expr = builtins.length (funnyNames (den.ctx.ctx-0 { x = "v"; }));
+        expected = 10;
+      }
+    );
+
+    test-ctx-chain-20 = denTest (
+      { den, funnyNames, ... }:
+      {
+        imports = mkCtxModules 20;
+        expr = builtins.length (funnyNames (den.ctx.ctx-0 { x = "v"; }));
+        expected = 20;
+      }
+    );
+
+    test-ctx-fan-out-20 = denTest (
+      { den, funnyNames, ... }:
+      {
+        imports = [
+          (
+            { den, ... }:
+            {
+              den.ctx.root = {
+                description = "root";
+                _.root =
+                  { x }:
+                  {
+                    funny.names = [ "root-${x}" ];
+                  };
+                into.leaf = { x }: lib.genList (i: { x = "${x}-${toString i}"; }) 20;
+              };
+              den.ctx.leaf._.leaf =
+                { x }:
+                {
+                  funny.names = [ "leaf-${x}" ];
+                };
+            }
+          )
+        ];
+        expr = builtins.length (funnyNames (den.ctx.root { x = "v"; }));
+        expected = 21;
+      }
+    );
+
+  };
+}

templates/ci/modules/features/perf/depth.nix

@@ -0,0 +1,90 @@
+{ denTest, lib, ... }:
+let
+  mkChain =
+    n:
+    let
+      go =
+        i:
+        if i >= n then
+          { funny.names = [ "leaf" ]; }
+        else
+          {
+            funny.names = [ "level-${toString i}" ];
+            includes = [ (go (i + 1)) ];
+          };
+    in
+    go 0;
+
+  mkWide = n: {
+    funny.names = [ "root" ];
+    includes = lib.genList (i: { funny.names = [ "branch-${toString i}" ]; }) n;
+  };
+
+  mkDeepWide =
+    depth: width:
+    let
+      go =
+        d:
+        if d >= depth then
+          {
+            funny.names = [ "leaf-d${toString d}" ];
+            includes = lib.genList (i: { funny.names = [ "wide-d${toString d}-${toString i}" ]; }) width;
+          }
+        else
+          {
+            funny.names = [ "level-${toString d}" ];
+            includes = [ (go (d + 1)) ];
+          };
+    in
+    go 0;
+in
+{
+  flake.tests.perf-depth = {
+
+    test-deep-10 = denTest (
+      { den, funnyNames, ... }:
+      {
+        den.aspects.deep = mkChain 10;
+        expr = builtins.length (funnyNames den.aspects.deep);
+        expected = 11;
+      }
+    );
+
+    test-deep-50 = denTest (
+      { den, funnyNames, ... }:
+      {
+        den.aspects.deep = mkChain 50;
+        expr = builtins.length (funnyNames den.aspects.deep);
+        expected = 51;
+      }
+    );
+
+    test-wide-50 = denTest (
+      { den, funnyNames, ... }:
+      {
+        den.aspects.wide = mkWide 50;
+        expr = builtins.length (funnyNames den.aspects.wide);
+        expected = 51;
+      }
+    );
+
+    test-wide-100 = denTest (
+      { den, funnyNames, ... }:
+      {
+        den.aspects.wide = mkWide 100;
+        expr = builtins.length (funnyNames den.aspects.wide);
+        expected = 101;
+      }
+    );
+
+    test-deep-wide-10x10 = denTest (
+      { den, funnyNames, ... }:
+      {
+        den.aspects.dw = mkDeepWide 10 10;
+        expr = builtins.length (funnyNames den.aspects.dw);
+        expected = 21;
+      }
+    );
+
+  };
+}

templates/ci/modules/test-support/eval-den.nix

@@ -51,7 +51,8 @@ let
       funnyNames =
         aspect:
         let
-          mod = aspect.resolve { class = "funny"; };
+          resolve = config.den.lib.aspects.resolve;
+          mod = resolve "funny" [ ] aspect;
           namesMod = {
             options.names = lib.mkOption {
               type = lib.types.listOf lib.types.str;