add TryFrom for NonZeroInteger types

[valarauca]

Adds TryFrom<{integer}> for NonZero{integer} types.

Piggybacks the existing TryFrom<{integer}> (to handle ranges) as well the NonZero{integer}::new (to handle the zero check). Meaning no new logic is added in this patch. Existing logic is just chained together.

[rust-highfive]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @sfackler (or someone else) soon.

If any changes to this PR are deemed necessary, please add them as extra commits. This ensures that the reviewer can see what has changed since they last reviewed the code. Due to the way GitHub handles out-of-date commits, this should also make it reasonably obvious what issues have or haven't been addressed. Large or tricky changes may require several passes of review and changes.

Please see the contribution instructions for more information.

[sfackler]

@rfcbot fcp merge

This adds TryFrom impls to convert any integer type to any nonzero integer type.

[rfcbot]

Team member @sfackler has proposed to merge this. The next step is review by the rest of the tagged team members:

• @Amanieu
• @SimonSapin
• @dtolnay
• @sfackler
• @withoutboats

Concerns:

• too much or too little (add TryFrom for NonZeroInteger types #72712 (comment))

Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!

See this document for info about what commands tagged team members can give me.

[rfcbot]

🔔 This is now entering its final comment period, as per the review above. 🔔

[SimonSapin]

@rfcbot concern too much or too little

This PR is conflating two kinds of conversion:

• Between integers of different bit width or signedness
• From primitive to non-zero

It’s two different conversions chained, conceptually and even in the implementation. As far as I know there is no precedent so far for this. For example we have u32: From<NonZeroU32> and u64: From<u32>, but not u64: From<NonZeroU32>.

I think I’d prefer for this PR to stick to TryFrom impls that can simply call a new constructor, and let users chain conversions explicitly if they wish.

Or, if uses cases (please explain them!) for chained conversion in a single impl are deemed useful enough, for consistency this PR should also add all combinations of conversions from non-zero to primitive integers. Note that some combinations should be From rather than (only) TryFrom.

[SimonSapin]

@rfcbot concern too much or too little

[valarauca]

Or, if uses cases (please explain them!) for chained conversion in a single impl are deemed useful enough

Given the existence of TryFrom<{Signed}> for {Unsigned} (and its inverse) for all bitwidths. Especially when the std::convert::TryFrom<_> documentation introduces the core concept the trait expresses via integer bit-width conversions. The extension of TryFrom to NonZero{integer} seems obvious?

The primary usecase is reduction in boilerplate and simplicity. The fact the only alternative, to convert all integer types into a NonZero{integer} (without casting), is to write something like:

use std::{convert::TryFrom, num::NonZeroI8};

pub fn into_nzi8<T>(x: T) -> Option<NonZeroI8>
where
    i8: TryFrom<T>,
{
    i8::try_from(x).ok().and_then(NonZeroI8::new)
}

This is some non-trivial generic boilerplate for integer conversions!

Hopefully this speaks for itself as a failure of usability/ergonomics. The added storage semantics of NonZero{integer} do not justify additional ceremony in its creation.

While the chained conversion does increase the complexity. The chain is intuitive based on existing documentation & type names. The declaration TryFrom<u64> to NonZeroI8 speaks for itself. It will accept all values within the (1..=127) range, all others will see an error.

---

[...] for consistency this PR should also add all combinations of conversions from non-zero to primitive integers. Note that some combinations should be From rather than (only) TryFrom

Could you say more? If this is request for the inverse operations I can facilitate it.

[SimonSapin]

The fact the only alternative, to convert all integer types into a NonZero{integer} (without casting), is to write something like: […]

Right, but how often to you actually want to do that in the first place?

I’m not totally opposed to adding these "implicitly chained" conversions if the rest of @rust-lang/libs is on board. Only this wasn’t apparent in the PR description or FCP proposal, and I feel it should be a deliberate decision.

[...] for consistency this PR should also add all combinations of conversions from non-zero to primitive integers. Note that some combinations should be From rather than (only) TryFrom

Could you say more? If this is request for the inverse operations I can facilitate it.

I mean, assuming we want to go in that direction:

• For every existing impl From<A> for B where A and B are primitive integer types, add impl From<NonZeroA> for B
• For every (other) existing impl TryFrom<A> for B where A and B are primitive integer types, add impl TryFrom<NonZeroA> for B

[valarauca]

Is there anything I can do help advance this decision making process?

AFAIT, the decision is now being left up to Libs-Team internal politics to determine what, if any, future actions are required.

[sfackler]

I think it might be best to add only the same-width conversions for now and leave the others for a later time.