integers

In the absence of overflow, which happens away from zero, signed integers behave like ordinary mathematical integers.

The corner cases for signed integers involve undefined behavior, the corner cases for unsigned integers involve overflow.

B) arbitrary precision integers: this is nicer, but even today significantly more expensive than ordinary integers.

No, I reply, I claimed that it contained all of the positive integers, not only the positive integers.

Similarly if you use some compiler specific option to ensure wrapping behaviour for signed integers like GCC -fwrapv.

The problem with unsigned integers is that most people, past me included, think that it prevents nonsense negative values.

What bugs have you seen that were caused in part by the choice to use signed integers?

The good point of using unsigned integers is that you have twice the available codes, because the extra bit.

Every single one of those cases involve integers that necessarily must be signed, in order for the interface to work.

There were discussions about that few months ago, because of differences deep down between platforms builtin types (js integers, etc).

Any time you mix them you get unsigned integers, which can give you big surprises.

Without signed integers, the scaling function will turn arguments like (-4, -3) to garbage.

My general rule of thumb is "use unsigned integers when interfacing with hardware, otherwise use int.".

Unsigned integers have a big "cliff" immediately to the left of zero.

But then you ask it, "Do you contain negative one?" and the box answers "Yes." And now you protest: I claimed that the box contained only positive integers.

> there's no need to use switch statements and their associated complexity to map integers back into addresses, when all that's really required is for the "caller" to supply a where-to-go-next address.