Recursive attribute sets ======================== The construction behaviour of recursive attribute sets is very specific, and a bit peculiar. In essence, there are multiple "phases" of scoping that take place during attribute set construction: 1. Every inherited value without an explicit source is inherited only from the **outer** scope in which the attribute set is enclosed. 2. A new scope is opened in which all recursive keys are evaluated. This only considers **statically known keys**, attributes can **not** recurse into dynamic keys in `self`! For example, this code is invalid in C++ Nix: ``` nix-repl> rec { ${"a"+""} = 2; b = a * 10; } error: undefined variable 'a' at (string):1:26 ``` 3. Finally, a third scope is opened in which dynamic keys are evaluated. This behaviour, while possibly a bit strange and unexpected, actually simplifies the implementation of recursive attribute sets in Tvix as well. Essentially, a recursive attribute set like this: ```nix rec { inherit a; b = a * 10; ${"c" + ""} = b * 2; } ``` Can be compiled like the following expression: ```nix let inherit a; in let b = a * 10; in { inherit a b; ${"c" + ""} = b * 2; } ``` Completely deferring the resolution of recursive identifiers to the existing handling of recursive scopes (i.e. deferred access) in let bindings. In practice, we can further specialise this and compile each scope directly into the form expected by `OpAttrs` (that is, leaving attribute names on the stack) before each value's position. C++ Nix's Implementation ------------------------ * [`ExprAttrs`](https://github.com/NixOS/nix/blob/2097c30b08af19a9b42705fbc07463bea60dfb5b/src/libexpr/nixexpr.hh#L241-L268) (AST representation of attribute sets) * [`ExprAttrs::eval`](https://github.com/NixOS/nix/blob/075bf6e5565aff9fba0ea02f3333c82adf4dccee/src/libexpr/eval.cc#L1333-L1414) * [`addAttr`](https://github.com/NixOS/nix/blob/master/src/libexpr/parser.y#L98-L156) (`ExprAttrs` construction in the parser)