Missing different-size int <-> NonZeroInt conversions

[clarfonthey]

Right now, we have most of the integer type interconversions implemented, but we're missing some falliable NonZero conversions. Namely these:

• iN -> NonZeroIM (where N != M)
• uN -> NonZeroIM (where N != M)
• iN -> NonZeroUM (where N != M)
• uN -> NonZeroUM (where N != M)
• NonZeroIN -> iM (where N != M)
• NonZeroIN -> uM (where N != M)
• NonZeroUN -> iM (where N != M)
• NonZeroUN -> uM (where N != M)

Right now, all of the integer <-> non-zero integer conversions only operate on types of the same size, rather than all the different sizes that the usual conversions allow.

Not sure if these sorts of conversions would be accepted, but my guess is that closing the transitive gap would be a good idea.

[leonardo-m]

You're right, they are useful, this conversion contains an useless division by zero test:

#[cfg(target_pointer_width = "64")]
pub fn foo(x: u64, y: NonZeroUsize) -> u64 {
    x / (y.get() as u64)
}

[clarfonthey]

There is an implementation for division by nonzero now, but yeah, there are cases where it'd be nice. But the question is mostly if they are worth the effort to add.