core/convert/
num.rs

1use crate::num::TryFromIntError;
2
3mod private {
4    /// This trait being unreachable from outside the crate
5    /// prevents other implementations of the `FloatToInt` trait,
6    /// which allows potentially adding more trait methods after the trait is `#[stable]`.
7    #[unstable(feature = "convert_float_to_int", issue = "67057")]
8    pub trait Sealed {}
9}
10
11/// Supporting trait for inherent methods of `f32` and `f64` such as `to_int_unchecked`.
12/// Typically doesn’t need to be used directly.
13#[unstable(feature = "convert_float_to_int", issue = "67057")]
14pub trait FloatToInt<Int>: private::Sealed + Sized {
15    #[unstable(feature = "convert_float_to_int", issue = "67057")]
16    #[doc(hidden)]
17    unsafe fn to_int_unchecked(self) -> Int;
18}
19
20macro_rules! impl_float_to_int {
21    ($Float:ty => $($Int:ty),+) => {
22        #[unstable(feature = "convert_float_to_int", issue = "67057")]
23        impl private::Sealed for $Float {}
24        $(
25            #[unstable(feature = "convert_float_to_int", issue = "67057")]
26            impl FloatToInt<$Int> for $Float {
27                #[inline]
28                unsafe fn to_int_unchecked(self) -> $Int {
29                    // SAFETY: the safety contract must be upheld by the caller.
30                    unsafe { crate::intrinsics::float_to_int_unchecked(self) }
31                }
32            }
33        )+
34    }
35}
36
37impl_float_to_int!(f16 => u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
38impl_float_to_int!(f32 => u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
39impl_float_to_int!(f64 => u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
40impl_float_to_int!(f128 => u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
41
42// Conversion traits for primitive integer and float types
43// Conversions T -> T are covered by a blanket impl and therefore excluded
44// Some conversions from and to usize/isize are not implemented due to portability concerns
45macro_rules! impl_from {
46    (bool => $Int:ty $(,)?) => {
47        impl_from!(
48            bool => $Int,
49            #[stable(feature = "from_bool", since = "1.28.0")],
50            concat!(
51                "Converts a [`bool`] to [`", stringify!($Int), "`] losslessly.\n",
52                "The resulting value is `0` for `false` and `1` for `true` values.\n",
53                "\n",
54                "# Examples\n",
55                "\n",
56                "```\n",
57                "assert_eq!(", stringify!($Int), "::from(true), 1);\n",
58                "assert_eq!(", stringify!($Int), "::from(false), 0);\n",
59                "```\n",
60            ),
61        );
62    };
63    ($Small:ty => $Large:ty, #[$attr:meta] $(,)?) => {
64        impl_from!(
65            $Small => $Large,
66            #[$attr],
67            concat!("Converts [`", stringify!($Small), "`] to [`", stringify!($Large), "`] losslessly."),
68        );
69    };
70    ($Small:ty => $Large:ty, #[$attr:meta], $doc:expr $(,)?) => {
71        #[$attr]
72        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
73        impl const From<$Small> for $Large {
74            // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
75            // Rustdocs on functions do not.
76            #[doc = $doc]
77            #[inline(always)]
78            fn from(small: $Small) -> Self {
79                small as Self
80            }
81        }
82    };
83}
84
85// boolean -> integer
86impl_from!(bool => u8);
87impl_from!(bool => u16);
88impl_from!(bool => u32);
89impl_from!(bool => u64);
90impl_from!(bool => u128);
91impl_from!(bool => usize);
92impl_from!(bool => i8);
93impl_from!(bool => i16);
94impl_from!(bool => i32);
95impl_from!(bool => i64);
96impl_from!(bool => i128);
97impl_from!(bool => isize);
98
99// unsigned integer -> unsigned integer
100impl_from!(u8 => u16, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
101impl_from!(u8 => u32, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
102impl_from!(u8 => u64, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
103impl_from!(u8 => u128, #[stable(feature = "i128", since = "1.26.0")]);
104impl_from!(u8 => usize, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
105impl_from!(u16 => u32, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
106impl_from!(u16 => u64, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
107impl_from!(u16 => u128, #[stable(feature = "i128", since = "1.26.0")]);
108impl_from!(u32 => u64, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
109impl_from!(u32 => u128, #[stable(feature = "i128", since = "1.26.0")]);
110impl_from!(u64 => u128, #[stable(feature = "i128", since = "1.26.0")]);
111
112// signed integer -> signed integer
113impl_from!(i8 => i16, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
114impl_from!(i8 => i32, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
115impl_from!(i8 => i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
116impl_from!(i8 => i128, #[stable(feature = "i128", since = "1.26.0")]);
117impl_from!(i8 => isize, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
118impl_from!(i16 => i32, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
119impl_from!(i16 => i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
120impl_from!(i16 => i128, #[stable(feature = "i128", since = "1.26.0")]);
121impl_from!(i32 => i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
122impl_from!(i32 => i128, #[stable(feature = "i128", since = "1.26.0")]);
123impl_from!(i64 => i128, #[stable(feature = "i128", since = "1.26.0")]);
124
125// unsigned integer -> signed integer
126impl_from!(u8 => i16, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
127impl_from!(u8 => i32, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
128impl_from!(u8 => i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
129impl_from!(u8 => i128, #[stable(feature = "i128", since = "1.26.0")]);
130impl_from!(u16 => i32, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
131impl_from!(u16 => i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
132impl_from!(u16 => i128, #[stable(feature = "i128", since = "1.26.0")]);
133impl_from!(u32 => i64, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
134impl_from!(u32 => i128, #[stable(feature = "i128", since = "1.26.0")]);
135impl_from!(u64 => i128, #[stable(feature = "i128", since = "1.26.0")]);
136
137// The C99 standard defines bounds on INTPTR_MIN, INTPTR_MAX, and UINTPTR_MAX
138// which imply that pointer-sized integers must be at least 16 bits:
139// http://port70.net/~nsz/c/c99/n1256.html#7.18.2.4
140impl_from!(u16 => usize, #[stable(feature = "lossless_iusize_conv", since = "1.26.0")]);
141impl_from!(u8 => isize, #[stable(feature = "lossless_iusize_conv", since = "1.26.0")]);
142impl_from!(i16 => isize, #[stable(feature = "lossless_iusize_conv", since = "1.26.0")]);
143
144// RISC-V defines the possibility of a 128-bit address space (RV128).
145
146// CHERI proposes 128-bit “capabilities”. Unclear if this would be relevant to usize/isize.
147// http://www.cl.cam.ac.uk/research/security/ctsrd/pdfs/20171017a-cheri-poster.pdf
148// http://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-951.pdf
149
150// Note: integers can only be represented with full precision in a float if
151// they fit in the significand, which is:
152// * 11 bits in f16
153// * 24 bits in f32
154// * 53 bits in f64
155// * 113 bits in f128
156// Lossy float conversions are not implemented at this time.
157// FIXME(f16_f128): The `f16`/`f128` impls `#[stable]` attributes should be changed to reference
158// `f16`/`f128` when they are stabilised (trait impls have to have a `#[stable]` attribute, but none
159// of the `f16`/`f128` impls can be used on stable as the `f16` and `f128` types are unstable).
160
161// signed integer -> float
162impl_from!(i8 => f16, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
163impl_from!(i8 => f32, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
164impl_from!(i8 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
165impl_from!(i8 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
166impl_from!(i16 => f32, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
167impl_from!(i16 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
168impl_from!(i16 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
169impl_from!(i32 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
170impl_from!(i32 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
171// FIXME(f16_f128): This impl would allow using `f128` on stable before it is stabilised.
172// impl_from!(i64 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
173
174// unsigned integer -> float
175impl_from!(u8 => f16, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
176impl_from!(u8 => f32, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
177impl_from!(u8 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
178impl_from!(u8 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
179impl_from!(u16 => f32, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
180impl_from!(u16 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
181impl_from!(u16 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
182impl_from!(u32 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
183impl_from!(u32 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
184// FIXME(f16_f128): This impl would allow using `f128` on stable before it is stabilised.
185// impl_from!(u64 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
186
187// float -> float
188// FIXME(f16_f128): adding additional `From<{float}>` impls to `f32` breaks inference. See
189// <http://github.com/rust-lang/rust/issues/123831>
190impl_from!(f16 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
191impl_from!(f16 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
192impl_from!(f32 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
193impl_from!(f32 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
194impl_from!(f64 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
195
196macro_rules! impl_float_from_bool {
197    (
198        $float:ty $(;
199            doctest_prefix: $(#[doc = $doctest_prefix:literal])*
200            doctest_suffix: $(#[doc = $doctest_suffix:literal])*
201        )?
202    ) => {
203        #[stable(feature = "float_from_bool", since = "1.68.0")]
204        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
205            impl const From<bool> for $float {
206            #[doc = concat!("Converts a [`bool`] to [`", stringify!($float),"`] losslessly.")]
207            /// The resulting value is positive `0.0` for `false` and `1.0` for `true` values.
208            ///
209            /// # Examples
210            /// ```
211            $($(#[doc = $doctest_prefix])*)?
212            #[doc = concat!("let x: ", stringify!($float)," = false.into();")]
213            /// assert_eq!(x, 0.0);
214            /// assert!(x.is_sign_positive());
215            ///
216            #[doc = concat!("let y: ", stringify!($float)," = true.into();")]
217            /// assert_eq!(y, 1.0);
218            $($(#[doc = $doctest_suffix])*)?
219            /// ```
220            #[inline]
221            fn from(small: bool) -> Self {
222                small as u8 as Self
223            }
224        }
225    };
226}
227
228// boolean -> float
229impl_float_from_bool!(
230    f16;
231    doctest_prefix:
232    // rustdoc doesn't remove the conventional space after the `///`
233    ///#![feature(f16)]
234    ///# #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
235    ///
236    doctest_suffix:
237    ///# }
238);
239impl_float_from_bool!(f32);
240impl_float_from_bool!(f64);
241impl_float_from_bool!(
242    f128;
243    doctest_prefix:
244    ///#![feature(f128)]
245    ///# #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
246    ///
247    doctest_suffix:
248    ///# }
249);
250
251// no possible bounds violation
252macro_rules! impl_try_from_unbounded {
253    ($source:ty => $($target:ty),+) => {$(
254        #[stable(feature = "try_from", since = "1.34.0")]
255        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
256        impl const TryFrom<$source> for $target {
257            type Error = TryFromIntError;
258
259            /// Tries to create the target number type from a source
260            /// number type. This returns an error if the source value
261            /// is outside of the range of the target type.
262            #[inline]
263            fn try_from(value: $source) -> Result<Self, Self::Error> {
264                Ok(value as Self)
265            }
266        }
267    )*}
268}
269
270// only negative bounds
271macro_rules! impl_try_from_lower_bounded {
272    ($source:ty => $($target:ty),+) => {$(
273        #[stable(feature = "try_from", since = "1.34.0")]
274        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
275        impl const TryFrom<$source> for $target {
276            type Error = TryFromIntError;
277
278            /// Tries to create the target number type from a source
279            /// number type. This returns an error if the source value
280            /// is outside of the range of the target type.
281            #[inline]
282            fn try_from(u: $source) -> Result<Self, Self::Error> {
283                if u >= 0 {
284                    Ok(u as Self)
285                } else {
286                    Err(TryFromIntError(()))
287                }
288            }
289        }
290    )*}
291}
292
293// unsigned to signed (only positive bound)
294macro_rules! impl_try_from_upper_bounded {
295    ($source:ty => $($target:ty),+) => {$(
296        #[stable(feature = "try_from", since = "1.34.0")]
297        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
298        impl const TryFrom<$source> for $target {
299            type Error = TryFromIntError;
300
301            /// Tries to create the target number type from a source
302            /// number type. This returns an error if the source value
303            /// is outside of the range of the target type.
304            #[inline]
305            fn try_from(u: $source) -> Result<Self, Self::Error> {
306                if u > (Self::MAX as $source) {
307                    Err(TryFromIntError(()))
308                } else {
309                    Ok(u as Self)
310                }
311            }
312        }
313    )*}
314}
315
316// all other cases
317macro_rules! impl_try_from_both_bounded {
318    ($source:ty => $($target:ty),+) => {$(
319        #[stable(feature = "try_from", since = "1.34.0")]
320        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
321        impl const TryFrom<$source> for $target {
322            type Error = TryFromIntError;
323
324            /// Tries to create the target number type from a source
325            /// number type. This returns an error if the source value
326            /// is outside of the range of the target type.
327            #[inline]
328            fn try_from(u: $source) -> Result<Self, Self::Error> {
329                let min = Self::MIN as $source;
330                let max = Self::MAX as $source;
331                if u < min || u > max {
332                    Err(TryFromIntError(()))
333                } else {
334                    Ok(u as Self)
335                }
336            }
337        }
338    )*}
339}
340
341macro_rules! rev {
342    ($mac:ident, $source:ty => $($target:ty),+) => {$(
343        $mac!($target => $source);
344    )*}
345}
346
347// unsigned integer -> unsigned integer
348impl_try_from_upper_bounded!(u16 => u8);
349impl_try_from_upper_bounded!(u32 => u8, u16);
350impl_try_from_upper_bounded!(u64 => u8, u16, u32);
351impl_try_from_upper_bounded!(u128 => u8, u16, u32, u64);
352
353// signed integer -> signed integer
354impl_try_from_both_bounded!(i16 => i8);
355impl_try_from_both_bounded!(i32 => i8, i16);
356impl_try_from_both_bounded!(i64 => i8, i16, i32);
357impl_try_from_both_bounded!(i128 => i8, i16, i32, i64);
358
359// unsigned integer -> signed integer
360impl_try_from_upper_bounded!(u8 => i8);
361impl_try_from_upper_bounded!(u16 => i8, i16);
362impl_try_from_upper_bounded!(u32 => i8, i16, i32);
363impl_try_from_upper_bounded!(u64 => i8, i16, i32, i64);
364impl_try_from_upper_bounded!(u128 => i8, i16, i32, i64, i128);
365
366// signed integer -> unsigned integer
367impl_try_from_lower_bounded!(i8 => u8, u16, u32, u64, u128);
368impl_try_from_both_bounded!(i16 => u8);
369impl_try_from_lower_bounded!(i16 => u16, u32, u64, u128);
370impl_try_from_both_bounded!(i32 => u8, u16);
371impl_try_from_lower_bounded!(i32 => u32, u64, u128);
372impl_try_from_both_bounded!(i64 => u8, u16, u32);
373impl_try_from_lower_bounded!(i64 => u64, u128);
374impl_try_from_both_bounded!(i128 => u8, u16, u32, u64);
375impl_try_from_lower_bounded!(i128 => u128);
376
377// usize/isize
378impl_try_from_upper_bounded!(usize => isize);
379impl_try_from_lower_bounded!(isize => usize);
380
381#[cfg(target_pointer_width = "16")]
382mod ptr_try_from_impls {
383    use super::TryFromIntError;
384
385    impl_try_from_upper_bounded!(usize => u8);
386    impl_try_from_unbounded!(usize => u16, u32, u64, u128);
387    impl_try_from_upper_bounded!(usize => i8, i16);
388    impl_try_from_unbounded!(usize => i32, i64, i128);
389
390    impl_try_from_both_bounded!(isize => u8);
391    impl_try_from_lower_bounded!(isize => u16, u32, u64, u128);
392    impl_try_from_both_bounded!(isize => i8);
393    impl_try_from_unbounded!(isize => i16, i32, i64, i128);
394
395    rev!(impl_try_from_upper_bounded, usize => u32, u64, u128);
396    rev!(impl_try_from_lower_bounded, usize => i8, i16);
397    rev!(impl_try_from_both_bounded, usize => i32, i64, i128);
398
399    rev!(impl_try_from_upper_bounded, isize => u16, u32, u64, u128);
400    rev!(impl_try_from_both_bounded, isize => i32, i64, i128);
401}
402
403#[cfg(target_pointer_width = "32")]
404mod ptr_try_from_impls {
405    use super::TryFromIntError;
406
407    impl_try_from_upper_bounded!(usize => u8, u16);
408    impl_try_from_unbounded!(usize => u32, u64, u128);
409    impl_try_from_upper_bounded!(usize => i8, i16, i32);
410    impl_try_from_unbounded!(usize => i64, i128);
411
412    impl_try_from_both_bounded!(isize => u8, u16);
413    impl_try_from_lower_bounded!(isize => u32, u64, u128);
414    impl_try_from_both_bounded!(isize => i8, i16);
415    impl_try_from_unbounded!(isize => i32, i64, i128);
416
417    rev!(impl_try_from_unbounded, usize => u32);
418    rev!(impl_try_from_upper_bounded, usize => u64, u128);
419    rev!(impl_try_from_lower_bounded, usize => i8, i16, i32);
420    rev!(impl_try_from_both_bounded, usize => i64, i128);
421
422    rev!(impl_try_from_unbounded, isize => u16);
423    rev!(impl_try_from_upper_bounded, isize => u32, u64, u128);
424    rev!(impl_try_from_unbounded, isize => i32);
425    rev!(impl_try_from_both_bounded, isize => i64, i128);
426}
427
428#[cfg(target_pointer_width = "64")]
429mod ptr_try_from_impls {
430    use super::TryFromIntError;
431
432    impl_try_from_upper_bounded!(usize => u8, u16, u32);
433    impl_try_from_unbounded!(usize => u64, u128);
434    impl_try_from_upper_bounded!(usize => i8, i16, i32, i64);
435    impl_try_from_unbounded!(usize => i128);
436
437    impl_try_from_both_bounded!(isize => u8, u16, u32);
438    impl_try_from_lower_bounded!(isize => u64, u128);
439    impl_try_from_both_bounded!(isize => i8, i16, i32);
440    impl_try_from_unbounded!(isize => i64, i128);
441
442    rev!(impl_try_from_unbounded, usize => u32, u64);
443    rev!(impl_try_from_upper_bounded, usize => u128);
444    rev!(impl_try_from_lower_bounded, usize => i8, i16, i32, i64);
445    rev!(impl_try_from_both_bounded, usize => i128);
446
447    rev!(impl_try_from_unbounded, isize => u16, u32);
448    rev!(impl_try_from_upper_bounded, isize => u64, u128);
449    rev!(impl_try_from_unbounded, isize => i32, i64);
450    rev!(impl_try_from_both_bounded, isize => i128);
451}
452
453// Conversion traits for non-zero integer types
454use crate::num::NonZero;
455
456macro_rules! impl_nonzero_int_from_nonzero_int {
457    ($Small:ty => $Large:ty) => {
458        #[stable(feature = "nz_int_conv", since = "1.41.0")]
459        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
460        impl const From<NonZero<$Small>> for NonZero<$Large> {
461            // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
462            // Rustdocs on functions do not.
463            #[doc = concat!("Converts <code>[NonZero]\\<[", stringify!($Small), "]></code> ")]
464            #[doc = concat!("to <code>[NonZero]\\<[", stringify!($Large), "]></code> losslessly.")]
465            #[inline]
466            fn from(small: NonZero<$Small>) -> Self {
467                // SAFETY: input type guarantees the value is non-zero
468                unsafe { Self::new_unchecked(From::from(small.get())) }
469            }
470        }
471    };
472}
473
474// non-zero unsigned integer -> non-zero unsigned integer
475impl_nonzero_int_from_nonzero_int!(u8 => u16);
476impl_nonzero_int_from_nonzero_int!(u8 => u32);
477impl_nonzero_int_from_nonzero_int!(u8 => u64);
478impl_nonzero_int_from_nonzero_int!(u8 => u128);
479impl_nonzero_int_from_nonzero_int!(u8 => usize);
480impl_nonzero_int_from_nonzero_int!(u16 => u32);
481impl_nonzero_int_from_nonzero_int!(u16 => u64);
482impl_nonzero_int_from_nonzero_int!(u16 => u128);
483impl_nonzero_int_from_nonzero_int!(u16 => usize);
484impl_nonzero_int_from_nonzero_int!(u32 => u64);
485impl_nonzero_int_from_nonzero_int!(u32 => u128);
486impl_nonzero_int_from_nonzero_int!(u64 => u128);
487
488// non-zero signed integer -> non-zero signed integer
489impl_nonzero_int_from_nonzero_int!(i8 => i16);
490impl_nonzero_int_from_nonzero_int!(i8 => i32);
491impl_nonzero_int_from_nonzero_int!(i8 => i64);
492impl_nonzero_int_from_nonzero_int!(i8 => i128);
493impl_nonzero_int_from_nonzero_int!(i8 => isize);
494impl_nonzero_int_from_nonzero_int!(i16 => i32);
495impl_nonzero_int_from_nonzero_int!(i16 => i64);
496impl_nonzero_int_from_nonzero_int!(i16 => i128);
497impl_nonzero_int_from_nonzero_int!(i16 => isize);
498impl_nonzero_int_from_nonzero_int!(i32 => i64);
499impl_nonzero_int_from_nonzero_int!(i32 => i128);
500impl_nonzero_int_from_nonzero_int!(i64 => i128);
501
502// non-zero unsigned -> non-zero signed integer
503impl_nonzero_int_from_nonzero_int!(u8 => i16);
504impl_nonzero_int_from_nonzero_int!(u8 => i32);
505impl_nonzero_int_from_nonzero_int!(u8 => i64);
506impl_nonzero_int_from_nonzero_int!(u8 => i128);
507impl_nonzero_int_from_nonzero_int!(u8 => isize);
508impl_nonzero_int_from_nonzero_int!(u16 => i32);
509impl_nonzero_int_from_nonzero_int!(u16 => i64);
510impl_nonzero_int_from_nonzero_int!(u16 => i128);
511impl_nonzero_int_from_nonzero_int!(u32 => i64);
512impl_nonzero_int_from_nonzero_int!(u32 => i128);
513impl_nonzero_int_from_nonzero_int!(u64 => i128);
514
515macro_rules! impl_nonzero_int_try_from_int {
516    ($Int:ty) => {
517        #[stable(feature = "nzint_try_from_int_conv", since = "1.46.0")]
518        impl TryFrom<$Int> for NonZero<$Int> {
519            type Error = TryFromIntError;
520
521            // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
522            // Rustdocs on functions do not.
523            #[doc = concat!("Attempts to convert [`", stringify!($Int), "`] ")]
524            #[doc = concat!("to <code>[NonZero]\\<[", stringify!($Int), "]></code>.")]
525            #[inline]
526            fn try_from(value: $Int) -> Result<Self, Self::Error> {
527                Self::new(value).ok_or(TryFromIntError(()))
528            }
529        }
530    };
531}
532
533// integer -> non-zero integer
534impl_nonzero_int_try_from_int!(u8);
535impl_nonzero_int_try_from_int!(u16);
536impl_nonzero_int_try_from_int!(u32);
537impl_nonzero_int_try_from_int!(u64);
538impl_nonzero_int_try_from_int!(u128);
539impl_nonzero_int_try_from_int!(usize);
540impl_nonzero_int_try_from_int!(i8);
541impl_nonzero_int_try_from_int!(i16);
542impl_nonzero_int_try_from_int!(i32);
543impl_nonzero_int_try_from_int!(i64);
544impl_nonzero_int_try_from_int!(i128);
545impl_nonzero_int_try_from_int!(isize);
546
547macro_rules! impl_nonzero_int_try_from_nonzero_int {
548    ($source:ty => $($target:ty),+) => {$(
549        #[stable(feature = "nzint_try_from_nzint_conv", since = "1.49.0")]
550        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
551        impl const TryFrom<NonZero<$source>> for NonZero<$target> {
552            type Error = TryFromIntError;
553
554            // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
555            // Rustdocs on functions do not.
556            #[doc = concat!("Attempts to convert <code>[NonZero]\\<[", stringify!($source), "]></code> ")]
557            #[doc = concat!("to <code>[NonZero]\\<[", stringify!($target), "]></code>.")]
558            #[inline]
559            fn try_from(value: NonZero<$source>) -> Result<Self, Self::Error> {
560                // SAFETY: Input is guaranteed to be non-zero.
561                Ok(unsafe { Self::new_unchecked(<$target>::try_from(value.get())?) })
562            }
563        }
564    )*};
565}
566
567// unsigned non-zero integer -> unsigned non-zero integer
568impl_nonzero_int_try_from_nonzero_int!(u16 => u8);
569impl_nonzero_int_try_from_nonzero_int!(u32 => u8, u16, usize);
570impl_nonzero_int_try_from_nonzero_int!(u64 => u8, u16, u32, usize);
571impl_nonzero_int_try_from_nonzero_int!(u128 => u8, u16, u32, u64, usize);
572impl_nonzero_int_try_from_nonzero_int!(usize => u8, u16, u32, u64, u128);
573
574// signed non-zero integer -> signed non-zero integer
575impl_nonzero_int_try_from_nonzero_int!(i16 => i8);
576impl_nonzero_int_try_from_nonzero_int!(i32 => i8, i16, isize);
577impl_nonzero_int_try_from_nonzero_int!(i64 => i8, i16, i32, isize);
578impl_nonzero_int_try_from_nonzero_int!(i128 => i8, i16, i32, i64, isize);
579impl_nonzero_int_try_from_nonzero_int!(isize => i8, i16, i32, i64, i128);
580
581// unsigned non-zero integer -> signed non-zero integer
582impl_nonzero_int_try_from_nonzero_int!(u8 => i8);
583impl_nonzero_int_try_from_nonzero_int!(u16 => i8, i16, isize);
584impl_nonzero_int_try_from_nonzero_int!(u32 => i8, i16, i32, isize);
585impl_nonzero_int_try_from_nonzero_int!(u64 => i8, i16, i32, i64, isize);
586impl_nonzero_int_try_from_nonzero_int!(u128 => i8, i16, i32, i64, i128, isize);
587impl_nonzero_int_try_from_nonzero_int!(usize => i8, i16, i32, i64, i128, isize);
588
589// signed non-zero integer -> unsigned non-zero integer
590impl_nonzero_int_try_from_nonzero_int!(i8 => u8, u16, u32, u64, u128, usize);
591impl_nonzero_int_try_from_nonzero_int!(i16 => u8, u16, u32, u64, u128, usize);
592impl_nonzero_int_try_from_nonzero_int!(i32 => u8, u16, u32, u64, u128, usize);
593impl_nonzero_int_try_from_nonzero_int!(i64 => u8, u16, u32, u64, u128, usize);
594impl_nonzero_int_try_from_nonzero_int!(i128 => u8, u16, u32, u64, u128, usize);
595impl_nonzero_int_try_from_nonzero_int!(isize => u8, u16, u32, u64, u128, usize);
core/convert/num.rs

core/convert/
num.rs
