Trait LosslessTryFrom 

pub trait LosslessTryFrom<Src>: Sized {
    // Required method
    fn lossless_try_from(src: Src) -> Option<Self>;
}

This trait provides lossless conversions that might be fallible.

This trait is implemented for conversions between integer primitives, floating-point primitives and fixed-point numbers.

Examples

use fixed::traits::LosslessTryFrom;
use fixed::types::{I24F8, I4F12};
// original is 0x000001.23, lossless is 0x1.230
let original = I24F8::from_bits(0x0000_0123);
let lossless = I4F12::lossless_try_from(original);
assert_eq!(lossless, Some(I4F12::from_bits(0x1230)));
// too_large is 0x000012.34, 0x12.340 does not fit in I4F12
let too_large = I24F8::from_bits(0x0000_1234);
let overflow = I4F12::lossless_try_from(too_large);
assert_eq!(overflow, None);

Required Methods

fn lossless_try_from(src: Src) -> Option<Self>

Performs the conversion.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl LosslessTryFrom<bool> for bool

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for i8

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for i16

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for i32

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for i64

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for i128

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for isize

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for u8

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for u16

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for u32

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for u64

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for u128

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bool> for usize

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<f32> for f32

fn lossless_try_from(src: f32) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<f32> for f64

fn lossless_try_from(src: f32) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<f64> for f64

fn lossless_try_from(src: f64) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i8> for f32

fn lossless_try_from(src: i8) -> Option<f32>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<i8> for f64

fn lossless_try_from(src: i8) -> Option<f64>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<i8> for i8

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i8> for i16

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i8> for i32

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i8> for i64

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i8> for i128

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i8> for isize

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i8> for u8

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i8> for u16

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i8> for u32

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i8> for u64

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i8> for u128

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i8> for usize

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i8> for f16

fn lossless_try_from(src: i8) -> Option<half_f16>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<i16> for f32

fn lossless_try_from(src: i16) -> Option<f32>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<i16> for f64

fn lossless_try_from(src: i16) -> Option<f64>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<i16> for i8

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i16> for i16

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i16> for i32

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i16> for i64

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i16> for i128

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i16> for isize

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i16> for u8

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i16> for u16

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i16> for u32

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i16> for u64

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i16> for u128

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i16> for usize

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for f64

fn lossless_try_from(src: i32) -> Option<f64>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<i32> for i8

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for i16

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for i32

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i32> for i64

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i32> for i128

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i32> for isize

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for u8

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for u16

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for u32

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for u64

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for u128

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for usize

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for i8

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for i16

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for i32

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for i64

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i64> for i128

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i64> for isize

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for u8

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for u16

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for u32

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for u64

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for u128

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for usize

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for i8

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for i16

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for i32

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for i64

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for i128

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<i128> for isize

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for u8

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for u16

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for u32

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for u64

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for u128

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for usize

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for i8

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for i16

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for i32

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for i64

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for i128

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for isize

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<isize> for u8

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for u16

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for u32

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for u64

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for u128

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for usize

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for f32

fn lossless_try_from(src: u8) -> Option<f32>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<u8> for f64

fn lossless_try_from(src: u8) -> Option<f64>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<u8> for i8

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for i16

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for i32

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for i64

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for i128

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for isize

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for u8

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for u16

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for u32

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for u64

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for u128

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for usize

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u8> for f16

fn lossless_try_from(src: u8) -> Option<half_f16>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<u16> for f32

fn lossless_try_from(src: u16) -> Option<f32>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<u16> for f64

fn lossless_try_from(src: u16) -> Option<f64>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<u16> for i8

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u16> for i16

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u16> for i32

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u16> for i64

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u16> for i128

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u16> for isize

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u16> for u8

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u16> for u16

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u16> for u32

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u16> for u64

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u16> for u128

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u16> for usize

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u32> for f64

fn lossless_try_from(src: u32) -> Option<f64>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<u32> for i8

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u32> for i16

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u32> for i32

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u32> for i64

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u32> for i128

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u32> for isize

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u32> for u8

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u32> for u16

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u32> for u32

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u32> for u64

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u32> for u128

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u32> for usize

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for i8

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for i16

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for i32

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for i64

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for i128

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u64> for isize

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for u8

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for u16

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for u32

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for u64

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u64> for u128

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u64> for usize

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for i8

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for i16

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for i32

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for i64

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for i128

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for isize

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for u8

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for u16

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for u32

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for u64

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for u128

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<u128> for usize

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for i8

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for i16

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for i32

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for i64

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for i128

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for isize

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for u8

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for u16

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for u32

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for u64

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for u128

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for usize

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for i8

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for i16

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for i32

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for i64

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for i128

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for isize

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for u8

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for u16

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for u32

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for u64

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for u128

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for usize

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for i8

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for i16

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for i32

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for i64

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for i128

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for isize

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for u8

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for u16

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for u32

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for u64

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for u128

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for usize

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for i8

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for i16

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for i32

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for i64

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for i128

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for isize

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for u8

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for u16

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for u32

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for u64

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for u128

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for usize

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for i8

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for i16

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for i32

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for i64

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for i128

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for isize

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for u8

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for u16

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for u32

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for u64

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for u128

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for usize

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i8

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i16

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i32

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i64

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i128

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for isize

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u8

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u16

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u32

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u64

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u128

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for usize

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for i8

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for i16

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for i32

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for i64

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for i128

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for isize

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for u8

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for u16

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for u32

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for u64

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for u128

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for usize

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for i8

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for i16

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for i32

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for i64

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for i128

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for isize

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for u8

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for u16

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for u32

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for u64

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for u128

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for usize

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for i8

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for i16

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for i32

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for i64

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for i128

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for isize

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for u8

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for u16

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for u32

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for u64

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for u128

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for usize

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for i8

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for i16

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for i32

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for i64

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for i128

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for isize

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for u8

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for u16

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for u32

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for u64

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for u128

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for usize

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for i8

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for i16

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for i32

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for i64

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for i128

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for isize

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for u8

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for u16

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for u32

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for u64

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for u128

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for usize

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<bf16> for f32

fn lossless_try_from(src: half_bf16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bf16> for f64

fn lossless_try_from(src: half_bf16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<bf16> for bf16

fn lossless_try_from(src: half_bf16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<f16> for f32

fn lossless_try_from(src: half_f16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<f16> for f64

fn lossless_try_from(src: half_f16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl LosslessTryFrom<f16> for f16

fn lossless_try_from(src: half_f16) -> Option<Self>

Converts a number.

This conversion actually never fails (infallible) and does not lose any precision (lossless).

impl<Frac: LeEqU8> LosslessTryFrom<FixedI8<Frac>> for f32

fn lossless_try_from(src: FixedI8<Frac>) -> Option<f32>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU8> LosslessTryFrom<FixedI8<Frac>> for f64

fn lossless_try_from(src: FixedI8<Frac>) -> Option<f64>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU8> LosslessTryFrom<FixedI8<Frac>> for f16

fn lossless_try_from(src: FixedI8<Frac>) -> Option<half_f16>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU8> LosslessTryFrom<FixedU8<Frac>> for f32

fn lossless_try_from(src: FixedU8<Frac>) -> Option<f32>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU8> LosslessTryFrom<FixedU8<Frac>> for f64

fn lossless_try_from(src: FixedU8<Frac>) -> Option<f64>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU8> LosslessTryFrom<FixedU8<Frac>> for f16

fn lossless_try_from(src: FixedU8<Frac>) -> Option<half_f16>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU16> LosslessTryFrom<FixedI16<Frac>> for f32

fn lossless_try_from(src: FixedI16<Frac>) -> Option<f32>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU16> LosslessTryFrom<FixedI16<Frac>> for f64

fn lossless_try_from(src: FixedI16<Frac>) -> Option<f64>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU16> LosslessTryFrom<FixedU16<Frac>> for f32

fn lossless_try_from(src: FixedU16<Frac>) -> Option<f32>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU16> LosslessTryFrom<FixedU16<Frac>> for f64

fn lossless_try_from(src: FixedU16<Frac>) -> Option<f64>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU32> LosslessTryFrom<FixedI32<Frac>> for f64

fn lossless_try_from(src: FixedI32<Frac>) -> Option<f64>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU32> LosslessTryFrom<FixedU32<Frac>> for f64

fn lossless_try_from(src: FixedU32<Frac>) -> Option<f64>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

Implementors

impl LosslessTryFrom<i8> for F128

impl LosslessTryFrom<i8> for F128Bits

impl LosslessTryFrom<i16> for F128

impl LosslessTryFrom<i16> for F128Bits

impl LosslessTryFrom<i32> for F128

impl LosslessTryFrom<i32> for F128Bits

impl LosslessTryFrom<i64> for F128

impl LosslessTryFrom<i64> for F128Bits

impl LosslessTryFrom<u8> for F128

impl LosslessTryFrom<u8> for F128Bits

impl LosslessTryFrom<u16> for F128

impl LosslessTryFrom<u16> for F128Bits

impl LosslessTryFrom<u32> for F128

impl LosslessTryFrom<u32> for F128Bits

impl LosslessTryFrom<u64> for F128

impl LosslessTryFrom<u64> for F128Bits

impl<Frac: LeEqU8> LosslessTryFrom<bool> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<bool> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i8> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i8> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i16> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i16> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i32> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i32> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i64> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i64> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i128> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i128> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<isize> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<isize> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u8> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u8> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u16> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u16> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u32> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u32> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u64> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u64> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u128> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u128> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<usize> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<usize> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<FixedI8<Frac>> for F128

impl<Frac: LeEqU8> LosslessTryFrom<FixedI8<Frac>> for F128Bits

impl<Frac: LeEqU8> LosslessTryFrom<FixedU8<Frac>> for F128

impl<Frac: LeEqU8> LosslessTryFrom<FixedU8<Frac>> for F128Bits

impl<Frac: LeEqU16> LosslessTryFrom<bool> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<bool> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i8> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i8> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i16> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i16> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i32> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i32> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i64> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i64> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i128> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i128> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<isize> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<isize> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u8> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u8> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u16> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u16> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u32> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u32> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u64> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u64> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u128> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u128> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<usize> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<usize> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<FixedI16<Frac>> for F128

impl<Frac: LeEqU16> LosslessTryFrom<FixedI16<Frac>> for F128Bits

impl<Frac: LeEqU16> LosslessTryFrom<FixedU16<Frac>> for F128

impl<Frac: LeEqU16> LosslessTryFrom<FixedU16<Frac>> for F128Bits

impl<Frac: LeEqU32> LosslessTryFrom<bool> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<bool> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i8> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i8> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i16> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i16> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i32> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i32> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i64> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i64> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i128> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i128> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<isize> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<isize> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u8> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u8> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u16> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u16> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u32> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u32> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u64> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u64> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u128> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u128> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<usize> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<usize> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<FixedI32<Frac>> for F128

impl<Frac: LeEqU32> LosslessTryFrom<FixedI32<Frac>> for F128Bits

impl<Frac: LeEqU32> LosslessTryFrom<FixedU32<Frac>> for F128

impl<Frac: LeEqU32> LosslessTryFrom<FixedU32<Frac>> for F128Bits

impl<Frac: LeEqU32> LosslessTryFrom<f16> for FixedI32<Frac>

where U24: IsLessOrEqual<Frac, Output = True>,

impl<Frac: LeEqU64> LosslessTryFrom<bool> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<bool> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i8> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i8> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i16> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i16> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i32> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i32> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i64> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i64> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i128> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i128> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<isize> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<isize> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u8> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u8> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u16> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u16> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u32> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u32> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u64> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u64> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u128> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u128> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<usize> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<usize> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<FixedI64<Frac>> for F128

impl<Frac: LeEqU64> LosslessTryFrom<FixedI64<Frac>> for F128Bits

impl<Frac: LeEqU64> LosslessTryFrom<FixedU64<Frac>> for F128

impl<Frac: LeEqU64> LosslessTryFrom<FixedU64<Frac>> for F128Bits

impl<Frac: LeEqU64> LosslessTryFrom<f16> for FixedI64<Frac>

where U24: IsLessOrEqual<Frac, Output = True>,

impl<Frac: LeEqU128> LosslessTryFrom<bool> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<bool> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i8> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i8> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i16> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i16> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i32> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i32> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i64> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i64> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i128> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i128> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<isize> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<isize> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u8> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u8> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u16> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u16> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u32> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u32> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u64> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u64> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u128> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u128> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<usize> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<usize> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<f16> for FixedI128<Frac>

where U24: IsLessOrEqual<Frac, Output = True>,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI8<FracSrc>> for FixedI8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI8<FracSrc>> for FixedU8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI16<FracSrc>> for FixedI8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI16<FracSrc>> for FixedU8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI32<FracSrc>> for FixedI8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI32<FracSrc>> for FixedU8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI64<FracSrc>> for FixedI8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI64<FracSrc>> for FixedU8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI128<FracSrc>> for FixedI8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI128<FracSrc>> for FixedU8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU8<FracSrc>> for FixedI8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU8<FracSrc>> for FixedU8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU16<FracSrc>> for FixedI8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU16<FracSrc>> for FixedU8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU32<FracSrc>> for FixedI8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU32<FracSrc>> for FixedU8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU64<FracSrc>> for FixedI8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU64<FracSrc>> for FixedU8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU128<FracSrc>> for FixedI8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU128<FracSrc>> for FixedU8<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI8<FracSrc>> for FixedI16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI8<FracSrc>> for FixedU16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI16<FracSrc>> for FixedI16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI16<FracSrc>> for FixedU16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI32<FracSrc>> for FixedI16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI32<FracSrc>> for FixedU16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI64<FracSrc>> for FixedI16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI64<FracSrc>> for FixedU16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI128<FracSrc>> for FixedI16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI128<FracSrc>> for FixedU16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU8<FracSrc>> for FixedI16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU8<FracSrc>> for FixedU16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU16<FracSrc>> for FixedI16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU16<FracSrc>> for FixedU16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU32<FracSrc>> for FixedI16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU32<FracSrc>> for FixedU16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU64<FracSrc>> for FixedI16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU64<FracSrc>> for FixedU16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU128<FracSrc>> for FixedI16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU128<FracSrc>> for FixedU16<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI8<FracSrc>> for FixedI32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI8<FracSrc>> for FixedU32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI16<FracSrc>> for FixedI32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI16<FracSrc>> for FixedU32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI32<FracSrc>> for FixedI32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI32<FracSrc>> for FixedU32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI64<FracSrc>> for FixedI32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI64<FracSrc>> for FixedU32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI128<FracSrc>> for FixedI32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI128<FracSrc>> for FixedU32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU8<FracSrc>> for FixedI32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU8<FracSrc>> for FixedU32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU16<FracSrc>> for FixedI32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU16<FracSrc>> for FixedU32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU32<FracSrc>> for FixedI32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU32<FracSrc>> for FixedU32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU64<FracSrc>> for FixedI32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU64<FracSrc>> for FixedU32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU128<FracSrc>> for FixedI32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU128<FracSrc>> for FixedU32<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI8<FracSrc>> for FixedI64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI8<FracSrc>> for FixedU64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI16<FracSrc>> for FixedI64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI16<FracSrc>> for FixedU64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI32<FracSrc>> for FixedI64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI32<FracSrc>> for FixedU64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI64<FracSrc>> for FixedI64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI64<FracSrc>> for FixedU64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI128<FracSrc>> for FixedI64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI128<FracSrc>> for FixedU64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU8<FracSrc>> for FixedI64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU8<FracSrc>> for FixedU64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU16<FracSrc>> for FixedI64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU16<FracSrc>> for FixedU64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU32<FracSrc>> for FixedI64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU32<FracSrc>> for FixedU64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU64<FracSrc>> for FixedI64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU64<FracSrc>> for FixedU64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU128<FracSrc>> for FixedI64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU128<FracSrc>> for FixedU64<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI8<FracSrc>> for FixedI128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI8<FracSrc>> for FixedU128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI16<FracSrc>> for FixedI128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI16<FracSrc>> for FixedU128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI32<FracSrc>> for FixedI128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI32<FracSrc>> for FixedU128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI64<FracSrc>> for FixedI128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI64<FracSrc>> for FixedU128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI128<FracSrc>> for FixedI128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI128<FracSrc>> for FixedU128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU8<FracSrc>> for FixedI128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU8<FracSrc>> for FixedU128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU16<FracSrc>> for FixedI128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU16<FracSrc>> for FixedU128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU32<FracSrc>> for FixedI128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU32<FracSrc>> for FixedU128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU64<FracSrc>> for FixedI128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU64<FracSrc>> for FixedU128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU128<FracSrc>> for FixedI128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU128<FracSrc>> for FixedU128<FracDst>

where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,