By "working as expected" I actually just meant that they distribute (as in a(b+c)=ab+ac) and commute (ab=ba and a+b=b+a), and those are true in all cases with two's compliment using simple adder and multiplier hardware*. The interpretation of any of these numbers being positive or negative is specious, but people still do it because it works reasonably well for small integers. Also, there's the definite advantage that you can use the same instructions for adding/multiplying signed and unsigned integers (for instance, pointer arithmetic).
You mention that the B6700 trapped on overflows. While this is a nice feature, this has nothing to do with the number format. The Intel hardware could have come with overflow trapping, yet it didn't...
One example of a nice thing about doing computations modulo 2^n is that you can do a bit twiddling trick called reciprocal multiplication (maybe sometimes called magic number multiplication). One reference for this is at [1]. Another reference is Hacker's Delight. But maybe you can save this for your ear's fingers.
I can't really say I understand why anyone would actually want to use Int (unless they knew they wanted a modulo 2^n Int). I think it's a bit of a shame it was given such a simple name instead of something like FastInt or some such (and in any case it's probably safer to use Int32 or Int64 since Int only guarantees representing signed numbers up to about 2^29 (!)).
I don't really know how well it optimizes, but Integer is actually (if you're using GMP with your ghc):
data Integer = S# Int# | J# Int# ByteArray# -- small integers and large integers, respectively
That Int# is the same as in "data Int = I# Int#", so you're not really saving anything, other than skipping bounds checking, by using Int instead of Integer.
Where are you getting that about C? Do you mean that it's careful to allow implementations to decide to trap overflows? Because as far as I can tell, the C standard just says signed overflows give undefined behavior.
Exercise for the reader: Make a new integer type called SafeInt... scratch that. The name was too good not to be taken, and sure enough, there's [2]. Although I was going to propose defining "data SafeInt = Overflow | SI Int64" and making an instance Num SafeInt which propagates Overflow (rather than using exceptions like in [2]).
Kyle
* It's unclear to me how important simple adder and multiplier hardware is these days. But, at least two's complement doesn't require defining case-by-case behavior as I'd expect a sign-and-magnitude operations to be defined.