Supers are not lazily evaluated

[Pacman99]

nix-repl> pop.lib.pop { supers = [ { a = throw "err"; b = 5; } ]; }
error: err

An attribute in a pop containing an error shouldn't error out the entire pop. Other attributes should still be accessible even if one attribute errors out.

The following code should print out 5, but it would just error out now.

p = pop.lib.pop { supers = [ { a = throw "err"; b = 5; } ]; }
p.b

cc @fare

[fare]

That sounds like a bug indeed: the list of supers should be eagerly evaluated to resolve the multiple inheritance hierarchy, but the fields of the super itself shouldn't. Maybe the bug though isn't in the super handling, but in the casting of prototype-less record to pop prototype? Even then that would be a bug, but a different one.

[Pacman99]

Maybe the bug though isn't in the super handling, but in the casting of prototype-less record to pop prototype?

I dont think so, I just used the plain attribute set as an example, but it happens even if that attrset was wrapped in a kPop.

pop.lib.pop { supers = [ (kPop { a = throw "err"; b = 5; }) ]; }

Also errors out.

[GTrunSec]

@fare Are there any inquiries pertaining to this matter? I also got the same problem when I trying embed POP into my instance. Thanks

[Pacman99]

I opened this NixOS/nix#8364

[fare]

https://twitter.com/Ngnghm/status/1717684526720094339

Lacking the ability to compare structures or functions by pointer identity, or system-provided nonces as identity tags, the only reliable solution is user-provided labels with some naming conventions to retrieve some modularity.

[fare]

Akshully, we might be able to do proper pointer equality: https://code.tvl.fyi/about/tvix/docs/value-pointer-equality.md

[Pacman99]

Yeah I just saw that thread! I might give that a try to see if we can fix this issue. I tried something similar with lists which sometimes worked, so hopefully this trick will work fully.

[fare]

Note that one part of the problem is ensuring that true is returned when the two are pointer-equal, the other part of the problem is ensuring that false is returned when they are not, instead of an error being thrown or an infinite branch taken.

[fare]

Here's a way to "purely" create tags you can compare for equality:

let generateTag = name: {id=:1; inherit name;} ; t1 = generateTag 1 ; t2 = generateTag 2 ; t2 = generateTag 2 ; in [(t1 == t1) (t1 == t2) (t2 == t2) (t2 == t2_)]

Or we can compare functions with {fun=next;} == {
The name is memoized purely for debugging reasons, but creating two tags with the same name yields different tags.

Beware that automatically wrapping

PS: The URL for the document above has changed to https://code.tvl.fyi/tree/tvix/docs/src/value-pointer-equality.md

[fare]

@Pacman99 Can you check whether my commit b6b81b1 fixes the issue?

[fare]

Also, I did some renaming, in line with my latest (still unfinished) sequel to the POOF article, my "Lambda, the Ultimate Object" essay.

Now distinguishing specification (the things you instantiate) from target (the thing instantiated), and calling prototype a target that remembers its specification, etc.

[rebmit]

Seems like builtins.elem here should also use pointer equality, e.g. builtins.any (t: getId t == getId c).

POP/POP.nix

Line 166 in b6b81b1

isCandidate = c: every (tail: !(builtins.elem c (builtins.tail tail))) tails;

[fare]

The problem is that if it falls back to infinitely deep field comparison when the identity comparison fails, then it may fall into non-termination.