Guide: what to do about int

[steveklabnik]

I've been using int because its familiar, but it may not be the right thing to suggest. Can we get a decision here?

[vks]

I don't understand the issue. What decision needs to be made? int vs. uint? int vs. int32 vs. int64?

[steveklabnik]

Int vs some sort of size. Generally, int is not actually what you want.

[vks]

Do you know what the intended use of int is? It has the same size as uint, which is always large enough to represent a pointer. However, I don't think anyone uses int to represent pointers. So unlike uint, it does not have a clear use case.

Machines with 64-bit pointers often have 64-bit arithmetic, in which using i64 is not as expensive as on machines with 32-bit arithmetic only.
However, I think they do not always have 64-bit arithmetic, so this is not reliable.

If int was guaranteed to have 64 bits if a corresponding arithmetic is available, it could be useful.
In its current state, I can't think of a case where you would want to use int.
It seems to me that it is currently used when people don't care whether it is an i32 or i64. (At least that is how I use it.) Unfortunately that leads to unnecessarily platform-dependent code.

I think the most sensible default to use would be i32, because this should give decent performance on most modern platforms.

[vks]

On uses of int:

Apparently the analogous type in C is used to store pointer offsets, which can be negative. See [1].
In Rust this is used by the unsafe offset method for raw pointers. [2]

So is it safe to say that int should only be used for such (unsafe) code?

[1] https://stackoverflow.com/questions/1464174/size-t-vs-intptr-t
[2] http://doc.rust-lang.org/std/ptr/trait.RawPtr.html#tymethod.offset

[l0kod]

From #16446:

As discussed in rust-lang/rfcs#115 and #9940, the int and uint should only be used for memory-related values (e.g. length).

The documentations mostly use i suffix examples. It should encourage the use of fixed-size integer (e.g. u32) for common uses.

Except for range or size-related values, the guide should use fixed-size integer examples (e.g. Variable bindings section), probably u32 (for interoperability).

The guide should highlight the relation of int and uint with the architecture/memory (maybe with the x32 example, cf. #14758), and why it could be dangerous to use them for other means.

[1fish2]

rust-lang/rust-guidelines#24 proposes integer style guidelines.

https://github.com/1fish2/Rust-rfcs/blob/int-index-for-portability/active/0000-intindex.md gives background on int and uint, common misconceptions, and interpretations of "default integer types."

In short, Rust defines integer types int and uint to be large enough to hold a pointer in the target environment. They aren't the fastest, "native," register, or C sized integers despite the names. They make sense for indexing and sizing in-memory containers, but using them for computations that are not limited by memory leads to code that's not portable to smaller-address targets than it was developed and tested on.

[pnkfelix]

What we decide here is going to have an impact on the interface to some of the libraries, such as std::container::Bitv (as mentioned in #16736).

Nominating; suggest 1.0 P-backcompat-libs.