Of course, that would upset Joel on account of not knowing what - did without knowing the types.
Forcing a and b to be different types could cause a different problem - maybe a worse one, depending on how many subtractions your code requires.
In practice, I find it best to avoid non-commutative functions with two arguments of the same type. The obvious choice (for a DB I'm writing):
addRecord :: ByteString -> ByteString -> IO Bool
addRecord key value = do ...
But this is safer: addRecord :: DBKey -> DBValue -> IO Bool
Now `addRecord value key` won't compile.Coding conventions don't detect errors, they just help to make them more obvious. For instance, if the variables had been named "cake" and "slice", it probably would have been a bit more obvious which side of the '-' sign each one should be on.
In any case, it's not an either-or choice between coding conventions and tests. A sensible developer will have both.
> In practice, I find it best to avoid non-commutative functions with two arguments of the same type.
I guess there's a silent "..where possible" attached to that? :-) There are many times where it's not possible, or at least not sensible; and having too many type conversions in your code can be just as bad for readability as having too few.
Here's a very simple counterexample that I don't believe it's possible for a compiler to detect: writing a - b when you should have written b - a. More generally, that applies to any non-commutative function which takes two arguments of the same type.
This is also a good example of where a coding convention could help: if those variables had been named more descriptively it would have been much easier to see which way around they should go.