Someone on IRC has brought up that multiplying an Int32 with an sf::Time object results in a compiler error, since it's both, implicitly converting to float or Int64, are legal and thus the compiler can't decide and marks it as ambiguous.
So for example this code will produce a compiler error:
sf::Time a = sf::seconds(1.f);
sf::Time b = a * 2;
use of overloaded operator '*' is ambiguous (with operand types 'sf::Time' and 'int')
Since one can't mark operators as explicit, I think we should add overloads for Int32 as well.
The true solution would be a template based on std::is_integral (http://en.cppreference.com/w/cpp/types/is_integral) and SFINAE or tag-dispatching. But I don't really like that for something so simple (and I'm sure Laurent does so even less ;))
Why would it be an issue for something so simple? It's a simple problem, so why not use a simple solution? (minus the waiting for C++11/14/17 though)
For now, what about an implicit cast to sf::Int64? Though, an overload for operator= (or overloaded constructor) would be needed as well.
Here's what I thought:
Time& operator=(Int64 i);
operator Int64() const;
Then that would allow arithmetic with whatever sf::Int64 can work with, and since sf::Time uses sf::Int64 internally, it should(?) work out.
That would allow people to do sf::Time a(5) and wanting 5 seconds, but I think that would be their fault for not reading the docs on what time unit the constructor expects. And I don't think that this would cause any compatibility issues (correct me if I'm wrong though!).