Stability and uniqueness of lambda-to-function-pointer conversion

Question

A capture-less lambda can be converted to a function pointer with the same parameter list as the lambda expression.

I am wondering whether this conversion is guaranteed to be stable, i.e. given a capture-less lambda expression, is it guaranteed by the standard that the function pointer conversion of any object of its type will always yield the same pointer value?

Furthermore, is it guaranteed that this pointer value is unique among lambda expressions and other functions?

auto x = []{};
auto x2 = x;
auto y = []{};
assert(+x == +x2); // ?
assert(+x != +y); // ?

Answer 1

The wording would seem to suggest that there's one function per type, so assert(+x == +x2); at least should hold:

[expr.prim.lambda.closure]/7 The closure type for a non-generic lambda-expression with no lambda-capture ... has a conversion function to pointer to function... The value returned by this conversion function is the address of a function F that, when invoked, has the same effect as invoking the closure type's function call operator on a default-constructed instance of the closure type.

This appears to say that there's a single function F, and that all instances of the closure type should convert to that function.

---

The standard doesn't seem to require or prohibit that distinct closure types convert to distinct functions. On the surface, it appears that +x != +y could go either way.