The issue is that for most things you'd want (+) to be defined like: (+) :: a -> a -> a
But actually, to be more flexible it could be defined as: (+) :: a -> b -> a
So then all the normal stuff would supported, as now, but you could also support things like:
instance BetterNum DateTime where
(+) :: DateTime -> Duration -> DateTime
Haskell’s type system does not prevent you from overloading the + operator. It’s the standard library (“Prelude”) that defines + to only work on numbers, and not on vectors, but with Haskell’s type system allows you to define + to do anything you want.
And for what it's worth, I certainly agree that the way Num is structured is a wart in Haskell, and I think the previous two commenters agree. It's just that we should be clear about where the blame lies - and that's not the type system.
Why is that bad? In Haskell, + is reserved for Num, which require some other properties that you can't guarantee for vectors. It'd be pretty bad to run afoul of that in a physics conversation.
Haskell certainly can let the + operator mean multiple things in multiple contexts.
Yes, as long as they have the structure your classes demand. It's not exactly Haskell's type system that is bad, it's the numeric classes that are a bit of a mess.
Math has a much cleaner structure that, for example, does not demand that you can convert any integral value into an instance of your numbers. Haskell tried to simplify it, but wasn't successful.