overload: ambiguous for compatible types

[Peter Remmers]

If you use final function objects to overload on types that are implicitly convertible to each other the overload becomes ambiguous.

Example:

struct X;
struct Y {
//	Y(const X&){} // enable this to fail
};
struct X {
//	operator Y() const { return Y(); }  // or enable this to fail
};

struct Foo final { void operator()(X) const { printf("X\n"); } };
struct Bar final { void operator()(Y) const { printf("Y\n"); } };
int main()
{
	auto ol = std::experimental::overload(Foo(), Bar());
	ol(X());
	return 0;
}

This ticket was opened as requested on https://github.com/viboes/tags/issues/7.

[Vicente J. Botet Escriba]

As discussed on the linked issue, I don't know how to fix it with the C++17. We will need something else in the language to fix it.

We could as well either forbid the overload of final function objects, to avoid surprises.
We will see what the committee think of this.

Thanks for catching this issue.
BTW, I will need your name if you agree I use it on any associated paper.

[Peter Remmers]

BTW, I will need your name if you agree I use it on any associated paper.

Uhh, sure, go ahead.

We will see what the committee think of this.

Interesting to see, indeed.