oeiuwq.com
fake.modules transposition for aspect-oriented Dendritic Nix. with cross-aspect dependencies. Discussions: https://oeiuwq.zulipchat.com/join/nqp26cd4kngon6mo3ncgnuap/
dendrix.oeiuwq.com/Dendritic.html
dendritic
nix
aspect
oriented
Remove `provides.itself` references and change `.provides.` -> `._.` in readme (#13)
authored by
Peter Esselius
and committed by
GitHub
4cbae79b
e3e8a7cc
+7
-11
README.md
+7
-11
README.md
···
86
nixos = {};
87
darwin = {};
88
89
-
provides.emulation = { aspect, ... }: {
90
nixos = {};
91
92
_.nes.nixos = {};
···
210
211
A provider can be either a static aspect object or a function that dynamically returns one. This mechanism enables sophisticated dependency chains, conditional logic, and parameterization.
212
213
-
#### The Default Provider: `provides.itself`
214
-
215
-
Every aspect automatically has a default provider called `itself`, located at `<aspect>.provides.itself`. This provider simply returns the aspect itself.
216
217
-
The `with aspects; [ bar baz ]` syntax is a convenient shorthand that relies on this default:
218
219
```nix
220
# A 'foo' aspect that depends on 'bar' and 'baz' aspects.
221
flake.aspects = { aspects, ... }: {
222
foo.includes = with aspects; [ bar baz ];
223
-
# This is equivalent to:
224
-
# foo.includes = [ aspects.bar.provides.itself aspects.baz.provides.itself ];
225
}
226
```
227
···
232
In this example, the `kde-desktop` aspect defines a custom `karousel` provider that only returns a module if certain conditions are met:
233
234
```nix
235
-
flake.aspects.kde-desktop.provides.karousel = { aspect-chain, class }:
236
if someCondition aspect-chain && class == "nixos" then { nixos = { ... }; } else { };
237
```
238
···
240
241
```nix
242
flake.aspects = { aspects, ... }: {
243
-
home-server.includes = [ aspects.kde-desktop.provides.karousel ];
244
}
245
```
246
···
256
flake.aspects = { aspects, ... }: {
257
system = {
258
nixos.system.stateVersion = "25.11";
259
-
provides.user = userName: {
260
darwin.system.primaryUser = userName;
261
nixos.users.${userName}.isNormalUser = true;
262
};
···
264
265
home-server.includes = [
266
aspects.system
267
-
(aspects.system.provides.user "bob")
268
];
269
}
270
```
···
86
nixos = {};
87
darwin = {};
88
89
+
_.emulation = { aspect, ... }: {
90
nixos = {};
91
92
_.nes.nixos = {};
···
210
211
A provider can be either a static aspect object or a function that dynamically returns one. This mechanism enables sophisticated dependency chains, conditional logic, and parameterization.
212
213
+
#### Default Provider (`__functor`)
214
215
+
Each aspect is itself a provider via its hidden option `__functor` (see `nix/types.nix`). You can include aspects directly.
216
217
```nix
218
# A 'foo' aspect that depends on 'bar' and 'baz' aspects.
219
flake.aspects = { aspects, ... }: {
220
foo.includes = with aspects; [ bar baz ];
221
}
222
```
223
···
228
In this example, the `kde-desktop` aspect defines a custom `karousel` provider that only returns a module if certain conditions are met:
229
230
```nix
231
+
flake.aspects.kde-desktop._.karousel = { aspect-chain, class }:
232
if someCondition aspect-chain && class == "nixos" then { nixos = { ... }; } else { };
233
```
234
···
236
237
```nix
238
flake.aspects = { aspects, ... }: {
239
+
home-server.includes = [ aspects.kde-desktop._.karousel ];
240
}
241
```
242
···
252
flake.aspects = { aspects, ... }: {
253
system = {
254
nixos.system.stateVersion = "25.11";
255
+
_.user = userName: {
256
darwin.system.primaryUser = userName;
257
nixos.users.${userName}.isNormalUser = true;
258
};
···
260
261
home-server.includes = [
262
aspects.system
263
+
(aspects.system._.user "bob")
264
];
265
}
266
```