Function equality is broken

[puckipedia]

As foretold by the code,

nix/src/libexpr/eval.cc

Line 1749 in 2e953b5

/* Functions are incomparable. */

And this seems to be true. If we try to evaluate this:

let lambda = (a: a); in lambda == lambda

We get a nice false result, as expected. But, what if ... we put the lambda in an attrset?

let lambda = (a: a); in { inherit lambda; } == { inherit lambda; }

Now, all of a sudden, the two attrsets are equal! But this is impossible, as functions are incomparable!

The reason for this is a 2010 hack added to support "some old broken code that relies on pointer equality":

nix/src/libexpr/eval.cc

Lines 1689 to 1692 in 2e953b5

	/* !!! Hack to support some old broken code that relies on pointer
	equality tests between sets. (Specifically, builderDefs calls
	uniqList on a list of sets.) Will remove this eventually. */
	if (&v1 == &v2) return true;

[7c6f434c]

Hm, as builderDefs do not exist in Nixpkgs anymore, and has been removed for a few years, I guess one could check whether there is a current use in the tree?

What does modules system listOf do when the same set is added multiple times?

[stale]

I marked this as stale due to inactivity. → More info

[andir]

This is still an issue to this date. Just came across the same behaviour while trying to generate random numbers in pure eval...

[stale]

I marked this as stale due to inactivity. → More info

[sternenseemann]

I looked into this again to be able to reimplement it accurately and tried writing up a summary. I think this also accounts aspects of the behavior that were not well-known before (i.e. that it works with non-functions as well and the wrapping value need not be an attribute set).

Also I came to the conclusion that we can't remove it as the platform sets in nixpkgs need to be comparable and contain functions. Even if we remove this in nixpkgs, we'll loose the ability to evaluate nixpkgs revisions people will care about. Maybe an experimental feature to disable it down the line would be possible.

[sternenseemann]

One (good?) thing is that pointer equality is based on the Value struct's location and not the location of an inner representation the struct has a pointer to. This means that when trying to (ab)use pointer equality, you are not able to in many cases, since Nix expressions create copies of Value structs all the time (e.g. select, function application, …, but identifier access does not):

let
  inherit (builtins) add;
  set = { inherit (builtins) add; };
in

[
  (set == set)                                                 # => true

  ({ inherit (set) add; } == { inherit (set) add; })           # => false
  ({ inherit (builtins) add; } == { inherit (builtins) add; }) # => false
  ({ inherit add; } == { inherit add; })                       # => true
]

See also #8462 (comment).