pub struct NonZeroIsize(_);
Available on non-crate feature miri-test-libstd only.
Expand description

An integer that is known not to equal zero.

This enables some memory layout optimization. For example, Option<NonZeroIsize> is the same size as isize:

use std::mem::size_of;
assert_eq!(size_of::<Option<core::num::NonZeroIsize>>(), size_of::<isize>());

Implementations§

source§

impl NonZeroIsize

const: 1.34.0 · source

pub const unsafe fn new_unchecked(n: isize) -> NonZeroIsize

Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.

Safety

The value must not be zero.

const: 1.47.0 · source

pub const fn new(n: isize) -> Option<NonZeroIsize>

Creates a non-zero if the given value is not zero.

const: 1.34.0 · source

pub const fn get(self) -> isize

Returns the value as a primitive type.

source§

impl NonZeroIsize

1.53.0 (const: 1.53.0) · source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

On many architectures, this function can perform better than leading_zeros() on the underlying integer type, as special handling of zero can be avoided.

Examples

Basic usage:

let n = std::num::NonZeroIsize::new(-1isize).unwrap();

assert_eq!(n.leading_zeros(), 0);
1.53.0 (const: 1.53.0) · source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

On many architectures, this function can perform better than trailing_zeros() on the underlying integer type, as special handling of zero can be avoided.

Examples

Basic usage:

let n = std::num::NonZeroIsize::new(0b0101000).unwrap();

assert_eq!(n.trailing_zeros(), 3);
source§

impl NonZeroIsize

1.64.0 (const: 1.64.0) · source

pub const fn abs(self) -> NonZeroIsize

Computes the absolute value of self. See isize::abs for documentation on overflow behaviour.

Example
let pos = NonZeroIsize::new(1)?;
let neg = NonZeroIsize::new(-1)?;

assert_eq!(pos, pos.abs());
assert_eq!(pos, neg.abs());
1.64.0 (const: 1.64.0) · source

pub const fn checked_abs(self) -> Option<NonZeroIsize>

Checked absolute value. Checks for overflow and returns None if self == isize::MIN. The result cannot be zero.

Example
let pos = NonZeroIsize::new(1)?;
let neg = NonZeroIsize::new(-1)?;
let min = NonZeroIsize::new(isize::MIN)?;

assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());
1.64.0 (const: 1.64.0) · source

pub const fn overflowing_abs(self) -> (NonZeroIsize, bool)

Computes the absolute value of self, with overflow information, see isize::overflowing_abs.

Example
let pos = NonZeroIsize::new(1)?;
let neg = NonZeroIsize::new(-1)?;
let min = NonZeroIsize::new(isize::MIN)?;

assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());
1.64.0 (const: 1.64.0) · source

pub const fn saturating_abs(self) -> NonZeroIsize

Saturating absolute value, see isize::saturating_abs.

Example
let pos = NonZeroIsize::new(1)?;
let neg = NonZeroIsize::new(-1)?;
let min = NonZeroIsize::new(isize::MIN)?;
let min_plus = NonZeroIsize::new(isize::MIN + 1)?;
let max = NonZeroIsize::new(isize::MAX)?;

assert_eq!(pos, pos.saturating_abs());
assert_eq!(pos, neg.saturating_abs());
assert_eq!(max, min.saturating_abs());
assert_eq!(max, min_plus.saturating_abs());
1.64.0 (const: 1.64.0) · source

pub const fn wrapping_abs(self) -> NonZeroIsize

Wrapping absolute value, see isize::wrapping_abs.

Example
let pos = NonZeroIsize::new(1)?;
let neg = NonZeroIsize::new(-1)?;
let min = NonZeroIsize::new(isize::MIN)?;

assert_eq!(pos, pos.wrapping_abs());
assert_eq!(pos, neg.wrapping_abs());
assert_eq!(min, min.wrapping_abs());
1.64.0 (const: 1.64.0) · source

pub const fn unsigned_abs(self) -> NonZeroUsize

Computes the absolute value of self without any wrapping or panicking.

Example

let u_pos = NonZeroUsize::new(1)?;
let i_pos = NonZeroIsize::new(1)?;
let i_neg = NonZeroIsize::new(-1)?;
let i_min = NonZeroIsize::new(isize::MIN)?;
let u_max = NonZeroUsize::new(usize::MAX / 2 + 1)?;

assert_eq!(u_pos, i_pos.unsigned_abs());
assert_eq!(u_pos, i_neg.unsigned_abs());
assert_eq!(u_max, i_min.unsigned_abs());
source

pub const fn is_negative(self) -> bool

🔬This is a nightly-only experimental API. (nonzero_negation_ops)

Returns true if self is negative and false if the number is positive.

Example
#![feature(nonzero_negation_ops)]

let pos_five = NonZeroIsize::new(5)?;
let neg_five = NonZeroIsize::new(-5)?;

assert!(neg_five.is_negative());
assert!(!pos_five.is_negative());
source

pub const fn checked_neg(self) -> Option<NonZeroIsize>

🔬This is a nightly-only experimental API. (nonzero_negation_ops)

Checked negation. Computes -self, returning None if self == i32::MIN.

Example
#![feature(nonzero_negation_ops)]

let pos_five = NonZeroIsize::new(5)?;
let neg_five = NonZeroIsize::new(-5)?;
let min = NonZeroIsize::new(isize::MIN)?;

assert_eq!(pos_five.checked_neg(), Some(neg_five));
assert_eq!(min.checked_neg(), None);
source

pub const fn overflowing_neg(self) -> (NonZeroIsize, bool)

🔬This is a nightly-only experimental API. (nonzero_negation_ops)

Negates self, overflowing if this is equal to the minimum value.

See isize::overflowing_neg for documentation on overflow behaviour.

Example
#![feature(nonzero_negation_ops)]

let pos_five = NonZeroIsize::new(5)?;
let neg_five = NonZeroIsize::new(-5)?;
let min = NonZeroIsize::new(isize::MIN)?;

assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));
source

pub const fn saturating_neg(self) -> NonZeroIsize

🔬This is a nightly-only experimental API. (nonzero_negation_ops)

Saturating negation. Computes -self, returning MAX if self == i32::MIN instead of overflowing.

Example
#![feature(nonzero_negation_ops)]

let pos_five = NonZeroIsize::new(5)?;
let neg_five = NonZeroIsize::new(-5)?;
let min = NonZeroIsize::new(isize::MIN)?;
let min_plus_one = NonZeroIsize::new(isize::MIN + 1)?;
let max = NonZeroIsize::new(isize::MAX)?;

assert_eq!(pos_five.saturating_neg(), neg_five);
assert_eq!(min.saturating_neg(), max);
assert_eq!(max.saturating_neg(), min_plus_one);
source

pub const fn wrapping_neg(self) -> NonZeroIsize

🔬This is a nightly-only experimental API. (nonzero_negation_ops)

Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.

See isize::wrapping_neg for documentation on overflow behaviour.

Example
#![feature(nonzero_negation_ops)]

let pos_five = NonZeroIsize::new(5)?;
let neg_five = NonZeroIsize::new(-5)?;
let min = NonZeroIsize::new(isize::MIN)?;

assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);
source§

impl NonZeroIsize

1.64.0 (const: 1.64.0) · source

pub const fn checked_mul(self, other: NonZeroIsize) -> Option<NonZeroIsize>

Multiplies two non-zero integers together. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.

Examples
let two = NonZeroIsize::new(2)?;
let four = NonZeroIsize::new(4)?;
let max = NonZeroIsize::new(isize::MAX)?;

assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
1.64.0 (const: 1.64.0) · source

pub const fn saturating_mul(self, other: NonZeroIsize) -> NonZeroIsize

Multiplies two non-zero integers together. Return isize::MAX on overflow.

Examples
let two = NonZeroIsize::new(2)?;
let four = NonZeroIsize::new(4)?;
let max = NonZeroIsize::new(isize::MAX)?;

assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
source

pub const unsafe fn unchecked_mul(self, other: NonZeroIsize) -> NonZeroIsize

🔬This is a nightly-only experimental API. (nonzero_ops)

Multiplies two non-zero integers together, assuming overflow cannot occur. Overflow is unchecked, and it is undefined behaviour to overflow even if the result would wrap to a non-zero value. The behaviour is undefined as soon as self * rhs > isize::MAX, or self * rhs < isize::MIN.

Examples
#![feature(nonzero_ops)]

let two = NonZeroIsize::new(2)?;
let four = NonZeroIsize::new(4)?;

assert_eq!(four, unsafe { two.unchecked_mul(two) });
1.64.0 (const: 1.64.0) · source

pub const fn checked_pow(self, other: u32) -> Option<NonZeroIsize>

Raises non-zero value to an integer power. Checks for overflow and returns None on overflow. As a consequence, the result cannot wrap to zero.

Examples
let three = NonZeroIsize::new(3)?;
let twenty_seven = NonZeroIsize::new(27)?;
let half_max = NonZeroIsize::new(isize::MAX / 2)?;

assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
1.64.0 (const: 1.64.0) · source

pub const fn saturating_pow(self, other: u32) -> NonZeroIsize

Raise non-zero value to an integer power. Return isize::MIN or isize::MAX on overflow.

Examples
let three = NonZeroIsize::new(3)?;
let twenty_seven = NonZeroIsize::new(27)?;
let max = NonZeroIsize::new(isize::MAX)?;

assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
source§

impl NonZeroIsize

1.70.0-nightly · source

pub const MIN: NonZeroIsize = Self::new(isize::MIN).unwrap()

The smallest value that can be represented by this non-zero integer type, equal to isize::MIN.

Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.

Examples
assert_eq!(NonZeroIsize::MIN.get(), isize::MIN);
1.70.0-nightly · source

pub const MAX: NonZeroIsize = Self::new(isize::MAX).unwrap()

The largest value that can be represented by this non-zero integer type, equal to isize::MAX.

Note: While most integer types are defined for every whole number between MIN and MAX, signed non-zero integers are a special case. They have a “gap” at 0.

Examples
assert_eq!(NonZeroIsize::MAX.get(), isize::MAX);
source§

impl NonZeroIsize

1.67.0 · source

pub const BITS: u32 = 64u32

The size of this non-zero integer type in bits.

This value is equal to isize::BITS.

Examples

assert_eq!(NonZeroIsize::BITS, isize::BITS);

Trait Implementations§

source§

impl Binary for NonZeroIsize

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.
1.45.0 (const: unstable) · source§

impl BitOr<NonZeroIsize> for NonZeroIsize

§

type Output = NonZeroIsize

The resulting type after applying the | operator.
const: unstable · source§

fn bitor( self, rhs: NonZeroIsize ) -> <NonZeroIsize as BitOr<NonZeroIsize>>::Output

Performs the | operation. Read more
1.45.0 (const: unstable) · source§

impl BitOr<NonZeroIsize> for isize

§

type Output = NonZeroIsize

The resulting type after applying the | operator.
const: unstable · source§

fn bitor(self, rhs: NonZeroIsize) -> <isize as BitOr<NonZeroIsize>>::Output

Performs the | operation. Read more
1.45.0 (const: unstable) · source§

impl BitOr<isize> for NonZeroIsize

§

type Output = NonZeroIsize

The resulting type after applying the | operator.
const: unstable · source§

fn bitor(self, rhs: isize) -> <NonZeroIsize as BitOr<isize>>::Output

Performs the | operation. Read more
1.45.0 (const: unstable) · source§

impl BitOrAssign<NonZeroIsize> for NonZeroIsize

const: unstable · source§

fn bitor_assign(&mut self, rhs: NonZeroIsize)

Performs the |= operation. Read more
1.45.0 (const: unstable) · source§

impl BitOrAssign<isize> for NonZeroIsize

const: unstable · source§

fn bitor_assign(&mut self, rhs: isize)

Performs the |= operation. Read more
source§

impl Clone for NonZeroIsize

source§

fn clone(&self) -> NonZeroIsize

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for NonZeroIsize

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

impl Display for NonZeroIsize

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
1.41.0 (const: unstable) · source§

impl From<NonZeroI16> for NonZeroIsize

const: unstable · source§

fn from(small: NonZeroI16) -> NonZeroIsize

Converts NonZeroI16 to NonZeroIsize losslessly.

1.41.0 (const: unstable) · source§

impl From<NonZeroI8> for NonZeroIsize

const: unstable · source§

fn from(small: NonZeroI8) -> NonZeroIsize

Converts NonZeroI8 to NonZeroIsize losslessly.

1.31.0 (const: unstable) · source§

impl From<NonZeroIsize> for isize

const: unstable · source§

fn from(nonzero: NonZeroIsize) -> isize

Converts a NonZeroIsize into an isize

1.41.0 (const: unstable) · source§

impl From<NonZeroU8> for NonZeroIsize

const: unstable · source§

fn from(small: NonZeroU8) -> NonZeroIsize

Converts NonZeroU8 to NonZeroIsize losslessly.

1.35.0 · source§

impl FromStr for NonZeroIsize

§

type Err = ParseIntError

The associated error which can be returned from parsing.
source§

fn from_str(src: &str) -> Result<NonZeroIsize, <NonZeroIsize as FromStr>::Err>

Parses a string s to return a value of this type. Read more
source§

impl Hash for NonZeroIsize

source§

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl LowerHex for NonZeroIsize

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.
source§

impl Octal for NonZeroIsize

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.
source§

impl Ord for NonZeroIsize

source§

fn cmp(&self, other: &NonZeroIsize) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval. Read more
source§

impl PartialEq<NonZeroIsize> for NonZeroIsize

source§

fn eq(&self, other: &NonZeroIsize) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialOrd<NonZeroIsize> for NonZeroIsize

source§

fn partial_cmp(&self, other: &NonZeroIsize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
1.49.0 · source§

impl TryFrom<NonZeroI128> for NonZeroIsize

source§

fn try_from( value: NonZeroI128 ) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroI128>>::Error>

Attempts to convert NonZeroI128 to NonZeroIsize.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroI32> for NonZeroIsize

source§

fn try_from( value: NonZeroI32 ) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroI32>>::Error>

Attempts to convert NonZeroI32 to NonZeroIsize.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroI64> for NonZeroIsize

source§

fn try_from( value: NonZeroI64 ) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroI64>>::Error>

Attempts to convert NonZeroI64 to NonZeroIsize.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroI128

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroI128, <NonZeroI128 as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroI128.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroI16

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroI16.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroI32

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroI32.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroI64

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroI64, <NonZeroI64 as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroI64.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroI8

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroI8.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroU128

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroU128.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroU16

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroU16.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroU32

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroU32.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroU64

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroU64.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroU8

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroU8.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroIsize> for NonZeroUsize

source§

fn try_from( value: NonZeroIsize ) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroIsize>>::Error>

Attempts to convert NonZeroIsize to NonZeroUsize.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroU128> for NonZeroIsize

source§

fn try_from( value: NonZeroU128 ) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroU128>>::Error>

Attempts to convert NonZeroU128 to NonZeroIsize.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroU16> for NonZeroIsize

source§

fn try_from( value: NonZeroU16 ) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroU16>>::Error>

Attempts to convert NonZeroU16 to NonZeroIsize.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroU32> for NonZeroIsize

source§

fn try_from( value: NonZeroU32 ) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroU32>>::Error>

Attempts to convert NonZeroU32 to NonZeroIsize.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroU64> for NonZeroIsize

source§

fn try_from( value: NonZeroU64 ) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroU64>>::Error>

Attempts to convert NonZeroU64 to NonZeroIsize.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.49.0 · source§

impl TryFrom<NonZeroUsize> for NonZeroIsize

source§

fn try_from( value: NonZeroUsize ) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroUsize>>::Error>

Attempts to convert NonZeroUsize to NonZeroIsize.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
1.46.0 · source§

impl TryFrom<isize> for NonZeroIsize

source§

fn try_from( value: isize ) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<isize>>::Error>

Attempts to convert isize to NonZeroIsize.

§

type Error = TryFromIntError

The type returned in the event of a conversion error.
source§

impl UpperHex for NonZeroIsize

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.
§

impl Value for NonZeroIsize

§

fn record(&self, key: &Field, visitor: &mut dyn Visit)

Visits this value with the given Visitor.
source§

impl Copy for NonZeroIsize

source§

impl Eq for NonZeroIsize

§

impl LifetimeFree for NonZeroIsize

source§

impl StructuralEq for NonZeroIsize

source§

impl StructuralPartialEq for NonZeroIsize

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> AsCleanDebug for Twhere T: Display,

source§

fn as_clean(&self) -> CleanDebug<'_, Self>where Self: Display,

Get a CleanDebug for Self. Read more
§

impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere T: 'a,

§

fn implicit( self, class: Class, constructed: bool, tag: u32 ) -> TaggedParser<'a, Implicit, Self, E>

source§

impl<T> Borrow<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
§

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
source§

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for Twhere U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

§

impl<T> Pointable for T

§

const ALIGN: usize = mem::align_of::<T>()

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same<T> for T

§

type Output = T

Should always be Self
§

impl<T> ToCompactString for Twhere T: Display,

§

fn to_compact_string(&self) -> CompactString

Converts the given value to a CompactString. Read more
source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
source§

impl<N> NodeTrait for Nwhere N: Copy + Ord + Hash,