'const' keyword changing semantics - c++

Question

I attempted today's leetcode challenge in C++. You have to find cousins in a binary tree. Here's my code.
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
class Solution {
public:
bool isCousins(TreeNode* root, int x, int y) {
this->x = x;
this->y = y;
return visit(overloaded{
[](const bool& r) {
return r;
},
[](const optional<int>& r) {
return false;
}
}, helper(root));
}
private:
int x;
int y;
variant<const bool, optional<int>> helper(TreeNode* node) {
if (node == nullptr) {
return variant<const bool, optional<int>>((optional<int>()));
}
else if (node->val == x) {
return variant<const bool, optional<int>>(optional<int>(0));
}
else if (node->val == y) {
return variant<const bool, optional<int>>(optional<int>(0));
}
else {
auto l = helper(node -> left);
auto r = helper(node -> right);
return visit(overloaded{
[](const bool& l, optional<int>& r) {
assert(!r.has_value());
return variant<const bool, optional<int>>(l);
},
[](optional<int>& l, const bool& r) {
assert(!l.has_value());
return variant<const bool, optional<int>>(r);
},
[](optional<int> l, optional<int> r) {
if (l.has_value() && r.has_value()) {
return variant<const bool, optional<int>>(*l > 0 && *l == *r);
}
else if (l.has_value()) {
++*l;
return variant<const bool, optional<int>>(l);
}
else if (r.has_value()) {
++*r;
return variant<const bool, optional<int>>(r);
}
else {
return variant<const bool, optional<int>>((optional<int>()));
}
}
}, l, r);
}
}
};
A testcase that demonstrates my issue is
[1,3,2,null,null,7,4,null,null,5,6,null,8,null,9]
8
9
The code above runs and completes successfully. However, if I remove a single const keyword in line 10 ([](bool& r) {) then it returns a different (incorrect) answer. const is for compile-time safety, so shouldn't affect semantics, but I guess something strange is happening with const overloading? What's going on exactly?
Possibly related: it also breaks my mental model that if, instead of declaring l, rin lines 34,35, I pass them directly as arguments to visit (ie. return visit(overloaded{..}, helper(node->left), helper(node->right)), it also fails. I would again expect that to have no effect on semantics.

Answer 1

Removing the const in this case changes the meaning of the code, by changing which function is selected in overload resolution.
Consider the following overload set and call:
void f(int const &) { std::cout << "i"; }
void f(bool) { std::cout << "b"; }
int main()
{
int const i = 42;
f(i); // prints i
f(42); // prints i
}
both call the first function (as expected), because a int const & binds to a int const, as well as int&& (a temporary int).
However, if we remove the const in the first function of the overload set, and make the same call:
void f(int &) { std::cout << "i"; }
void f(bool) { std::cout << "b"; }
int main()
{
int const i = 42;
f(i); // prints b
f(42); // prints b
}
the first function is not selected, because an int &, cannot bind to a int const. However, a bool can bind to an int const, (after an implicit conversion), and it calls the second function. Similarly, an int & cannot bind to a int&&, but a bool can, so it calls the second function.
This same reasoning applies to your example, but I've removed the variant, and custom overload set, as it simplifies the situation, without changing the underlying problem.