They way you implemented equals and less than operators brings to mind you don't mention how logical expressions and bitwise logical expression work in C++. I would also take about freestanding operator overloading btw in your operator overloading chapter.

bool operator < (const A& lhs, const A& rhs)
{
	return lhs.x < rhs.x && lhs.y < rhs.y
}

bool operator==(const A& lhs, const A& rhs)
{
	return lsh.x == rhs.x && lhs.y == rhs.y;
}

They can become super handy when you have to overload things you can't express with a member overload operator.

Vector2 myVector; //Vector has a Vector2 operator*(float scalar);

auto result = myVector * 2;
auto result = 2 * myVector; //you can't express this with a member function for example.

Also its generally easier to read a less than opertor that doesnt do a greater than operator to calculate the result. That might require the reader to do more mental work than needed in a few places. This works the same for conditional code its much easier to read the positive case instead of the negative case in an if expression specially when the logic expression becomes complicated. ALso that “!” in front of an expression can be hard to spot.

When you work on large codebases all these small things matter in how much energy you have to expend to understand code which matters when you look at a lot of code.

Unless you have accessors or differ to other functions in the public API. I dislike friend but yes this is a valid use for it.