Trait TryCoerce 

pub trait TryCoerce<R> {
    type Error;

    // Required method
    fn try_coerce(self) -> Result<R, Self::Error>;
}

Fallible coercion from Self to type R.

Implement this trait for narrowing conversions that may overflow or lose precision.

Required Associated Types

type Error

Error returned when coercion fails.

Required Methods

fn try_coerce(self) -> Result<R, Self::Error>

Attempt to convert self into R.

Implementations on Foreign Types

impl TryCoerce<bool> for i32

type Error = LogicalCoerceError

fn try_coerce(self) -> Result<bool, LogicalCoerceError>

impl TryCoerce<f64> for i64

Convert i64 to f64, failing if precision would be lost.

Only succeeds for values in [-2^53, 2^53].

type Error = CoerceError

fn try_coerce(self) -> Result<f64, CoerceError>

impl TryCoerce<f64> for isize

type Error = CoerceError

fn try_coerce(self) -> Result<f64, CoerceError>

impl TryCoerce<f64> for u64

Convert u64 to f64, failing if precision would be lost.

Only succeeds for values ≤ 2^53.

type Error = CoerceError

fn try_coerce(self) -> Result<f64, CoerceError>

impl TryCoerce<f64> for usize

type Error = CoerceError

fn try_coerce(self) -> Result<f64, CoerceError>

impl TryCoerce<i8> for f64

type Error = CoerceError

fn try_coerce(self) -> Result<i8, CoerceError>

impl TryCoerce<i8> for i16

type Error = CoerceError

fn try_coerce(self) -> Result<i8, CoerceError>

impl TryCoerce<i8> for i32

type Error = CoerceError

fn try_coerce(self) -> Result<i8, CoerceError>

impl TryCoerce<i8> for i64

type Error = CoerceError

fn try_coerce(self) -> Result<i8, CoerceError>

impl TryCoerce<i8> for isize

type Error = CoerceError

fn try_coerce(self) -> Result<i8, CoerceError>

impl TryCoerce<i8> for u8

type Error = CoerceError

fn try_coerce(self) -> Result<i8, CoerceError>

impl TryCoerce<i8> for u16

type Error = CoerceError

fn try_coerce(self) -> Result<i8, CoerceError>

impl TryCoerce<i8> for u32

type Error = CoerceError

fn try_coerce(self) -> Result<i8, CoerceError>

impl TryCoerce<i8> for u64

type Error = CoerceError

fn try_coerce(self) -> Result<i8, CoerceError>

impl TryCoerce<i8> for usize

type Error = CoerceError

fn try_coerce(self) -> Result<i8, CoerceError>

impl TryCoerce<i16> for f64

type Error = CoerceError

fn try_coerce(self) -> Result<i16, CoerceError>

impl TryCoerce<i16> for i32

type Error = CoerceError

fn try_coerce(self) -> Result<i16, CoerceError>

impl TryCoerce<i16> for i64

type Error = CoerceError

fn try_coerce(self) -> Result<i16, CoerceError>

impl TryCoerce<i16> for isize

type Error = CoerceError

fn try_coerce(self) -> Result<i16, CoerceError>

impl TryCoerce<i16> for u16

type Error = CoerceError

fn try_coerce(self) -> Result<i16, CoerceError>

impl TryCoerce<i16> for u32

type Error = CoerceError

fn try_coerce(self) -> Result<i16, CoerceError>

impl TryCoerce<i16> for u64

type Error = CoerceError

fn try_coerce(self) -> Result<i16, CoerceError>

impl TryCoerce<i16> for usize

type Error = CoerceError

fn try_coerce(self) -> Result<i16, CoerceError>

impl TryCoerce<i32> for f32

type Error = CoerceError

fn try_coerce(self) -> Result<i32, CoerceError>

impl TryCoerce<i32> for f64

type Error = CoerceError

fn try_coerce(self) -> Result<i32, CoerceError>

impl TryCoerce<i32> for i64

type Error = CoerceError

fn try_coerce(self) -> Result<i32, CoerceError>

impl TryCoerce<i32> for isize

type Error = CoerceError

fn try_coerce(self) -> Result<i32, CoerceError>

impl TryCoerce<i32> for u32

type Error = CoerceError

fn try_coerce(self) -> Result<i32, CoerceError>

impl TryCoerce<i32> for u64

type Error = CoerceError

fn try_coerce(self) -> Result<i32, CoerceError>

impl TryCoerce<i32> for usize

type Error = CoerceError

fn try_coerce(self) -> Result<i32, CoerceError>

impl TryCoerce<i64> for f64

Convert f64 to i64, validating exact representation.

type Error = CoerceError

fn try_coerce(self) -> Result<i64, CoerceError>

impl TryCoerce<isize> for f64

type Error = CoerceError

fn try_coerce(self) -> Result<isize, CoerceError>

impl TryCoerce<u8> for f32

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u8> for f64

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u8> for i8

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u8> for i16

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u8> for i32

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u8> for i64

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u8> for isize

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u8> for u16

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u8> for u32

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u8> for u64

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u8> for usize

type Error = CoerceError

fn try_coerce(self) -> Result<u8, CoerceError>

impl TryCoerce<u16> for f64

type Error = CoerceError

fn try_coerce(self) -> Result<u16, CoerceError>

impl TryCoerce<u16> for i8

type Error = CoerceError

fn try_coerce(self) -> Result<u16, CoerceError>

impl TryCoerce<u16> for i16

type Error = CoerceError

fn try_coerce(self) -> Result<u16, CoerceError>

impl TryCoerce<u16> for i32

type Error = CoerceError

fn try_coerce(self) -> Result<u16, CoerceError>

impl TryCoerce<u16> for i64

type Error = CoerceError

fn try_coerce(self) -> Result<u16, CoerceError>

impl TryCoerce<u16> for isize

type Error = CoerceError

fn try_coerce(self) -> Result<u16, CoerceError>

impl TryCoerce<u16> for u32

type Error = CoerceError

fn try_coerce(self) -> Result<u16, CoerceError>

impl TryCoerce<u16> for u64

type Error = CoerceError

fn try_coerce(self) -> Result<u16, CoerceError>

impl TryCoerce<u16> for usize

type Error = CoerceError

fn try_coerce(self) -> Result<u16, CoerceError>

impl TryCoerce<u32> for f64

type Error = CoerceError

fn try_coerce(self) -> Result<u32, CoerceError>

impl TryCoerce<u32> for i32

i32 -> u32: can fail if negative

type Error = CoerceError

fn try_coerce(self) -> Result<u32, CoerceError>

impl TryCoerce<u64> for f64

type Error = CoerceError

fn try_coerce(self) -> Result<u64, CoerceError>

impl TryCoerce<u64> for i32

i32 -> u64: can fail if negative

type Error = CoerceError

fn try_coerce(self) -> Result<u64, CoerceError>

impl TryCoerce<usize> for f64

type Error = CoerceError

fn try_coerce(self) -> Result<usize, CoerceError>

impl TryCoerce<usize> for i32

i32 -> usize: can fail if negative

type Error = CoerceError

fn try_coerce(self) -> Result<usize, CoerceError>

impl TryCoerce<NonZero<i8>> for i8

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroI8, CoerceError>

impl TryCoerce<NonZero<i8>> for i32

i32 -> NonZeroI8: narrow then check zero

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroI8, CoerceError>

impl TryCoerce<NonZero<i16>> for i16

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroI16, CoerceError>

impl TryCoerce<NonZero<i16>> for i32

i32 -> NonZeroI16: narrow then check zero

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroI16, CoerceError>

impl TryCoerce<NonZero<i32>> for i32

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroI32, CoerceError>

impl TryCoerce<NonZero<i64>> for i32

i32 -> NonZeroI64: widen then check zero

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroI64, CoerceError>

impl TryCoerce<NonZero<i64>> for i64

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroI64, CoerceError>

impl TryCoerce<NonZero<isize>> for i32

i32 -> NonZeroIsize: widen then check zero

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroIsize, CoerceError>

impl TryCoerce<NonZero<isize>> for isize

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroIsize, CoerceError>

impl TryCoerce<NonZero<u8>> for i32

i32 -> NonZeroU8: check non-negative, narrow, then check zero

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroU8, CoerceError>

impl TryCoerce<NonZero<u8>> for u8

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroU8, CoerceError>

impl TryCoerce<NonZero<u16>> for i32

i32 -> NonZeroU16: check non-negative, narrow, then check zero

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroU16, CoerceError>

impl TryCoerce<NonZero<u16>> for u16

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroU16, CoerceError>

impl TryCoerce<NonZero<u32>> for i32

i32 -> NonZeroU32: check non-negative and non-zero

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroU32, CoerceError>

impl TryCoerce<NonZero<u32>> for u32

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroU32, CoerceError>

impl TryCoerce<NonZero<u64>> for i32

i32 -> NonZeroU64: check non-negative and non-zero

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroU64, CoerceError>

impl TryCoerce<NonZero<u64>> for u64

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroU64, CoerceError>

impl TryCoerce<NonZero<usize>> for i32

i32 -> NonZeroUsize: check non-negative and non-zero

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroUsize, CoerceError>

impl TryCoerce<NonZero<usize>> for usize

type Error = CoerceError

fn try_coerce(self) -> Result<NonZeroUsize, CoerceError>

Implementors

impl TryCoerce<bool> for Rboolean

type Error = LogicalCoerceError

impl TryCoerce<bool> for RLogical

type Error = LogicalCoerceError

impl<T, R> TryCoerce<R> for T

where T: Coerce<R>,

type Error = Infallible