Trait fixed::traits::LossyFrom

pub trait LossyFrom<Src> {
    fn lossy_from(src: Src) -> Self;
}

This trait provides infallible conversions that might be lossy.

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

Examples

use fixed::traits::LossyFrom;
use fixed::types::{I12F4, I4F60};
// original is 0x1.234
let original = I4F60::from_bits(0x1234i64 << (60 - 12));
let lossy = I12F4::lossy_from(original);
assert_eq!(lossy, I12F4::from_bits(0x0012));

Required methods

fn lossy_from(src: Src) -> Self

Performs the conversion.

Loading content...

Implementations on Foreign Types

impl<Frac> LossyFrom<FixedI8<Frac>> for f16 where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn lossy_from(src: FixedI8<Frac>) -> f16

impl<Frac> LossyFrom<FixedI16<Frac>> for f16 where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn lossy_from(src: FixedI16<Frac>) -> f16

impl<Frac> LossyFrom<FixedI32<Frac>> for f16 where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn lossy_from(src: FixedI32<Frac>) -> f16

impl<Frac> LossyFrom<FixedI64<Frac>> for f16 where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn lossy_from(src: FixedI64<Frac>) -> f16

impl<Frac> LossyFrom<FixedI128<Frac>> for f16 where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn lossy_from(src: FixedI128<Frac>) -> f16

impl<Frac> LossyFrom<FixedU8<Frac>> for f16 where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn lossy_from(src: FixedU8<Frac>) -> f16

impl<Frac> LossyFrom<FixedU16<Frac>> for f16 where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn lossy_from(src: FixedU16<Frac>) -> f16

impl<Frac> LossyFrom<FixedU32<Frac>> for f16 where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn lossy_from(src: FixedU32<Frac>) -> f16

impl<Frac> LossyFrom<FixedU64<Frac>> for f16 where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn lossy_from(src: FixedU64<Frac>) -> f16

impl<Frac> LossyFrom<FixedU128<Frac>> for f16 where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn lossy_from(src: FixedU128<Frac>) -> f16

impl LossyFrom<i8> for f16

fn lossy_from(src: i8) -> f16

impl LossyFrom<i16> for f16

fn lossy_from(src: i16) -> f16

impl LossyFrom<i32> for f16

fn lossy_from(src: i32) -> f16

impl LossyFrom<i64> for f16

fn lossy_from(src: i64) -> f16

impl LossyFrom<i128> for f16

fn lossy_from(src: i128) -> f16

impl LossyFrom<isize> for f16

fn lossy_from(src: isize) -> f16

impl LossyFrom<u8> for f16

fn lossy_from(src: u8) -> f16

impl LossyFrom<u16> for f16

fn lossy_from(src: u16) -> f16

impl LossyFrom<u32> for f16

fn lossy_from(src: u32) -> f16

impl LossyFrom<u64> for f16

fn lossy_from(src: u64) -> f16

impl LossyFrom<u128> for f16

fn lossy_from(src: u128) -> f16

impl LossyFrom<usize> for f16

fn lossy_from(src: usize) -> f16

impl LossyFrom<f16> for f16

fn lossy_from(src: f16) -> f16

impl LossyFrom<f32> for f16

fn lossy_from(src: f32) -> f16

impl LossyFrom<f64> for f16

fn lossy_from(src: f64) -> f16

Loading content...

Implementors

impl LossyFrom<f16> for f32

fn lossy_from(src: f16) -> f32

impl LossyFrom<f16> for f64

fn lossy_from(src: f16) -> f64

impl LossyFrom<f32> for f32

fn lossy_from(src: f32) -> f32

impl LossyFrom<f32> for f64

fn lossy_from(src: f32) -> f64

impl LossyFrom<f64> for f32

fn lossy_from(src: f64) -> f32

impl LossyFrom<f64> for f64

fn lossy_from(src: f64) -> f64

impl LossyFrom<i128> for FixedI128<U0>

fn lossy_from(src: i128) -> FixedI128<U0>

impl LossyFrom<i128> for f32

fn lossy_from(src: i128) -> f32

impl LossyFrom<i128> for f64

fn lossy_from(src: i128) -> f64

impl LossyFrom<i16> for FixedI16<U0>

fn lossy_from(src: i16) -> FixedI16<U0>

impl LossyFrom<i16> for f32

fn lossy_from(src: i16) -> f32

impl LossyFrom<i16> for f64

fn lossy_from(src: i16) -> f64

impl LossyFrom<i32> for FixedI32<U0>

fn lossy_from(src: i32) -> FixedI32<U0>

impl LossyFrom<i32> for f32

fn lossy_from(src: i32) -> f32

impl LossyFrom<i32> for f64

fn lossy_from(src: i32) -> f64

impl LossyFrom<i64> for FixedI64<U0>

fn lossy_from(src: i64) -> FixedI64<U0>

impl LossyFrom<i64> for f32

fn lossy_from(src: i64) -> f32

impl LossyFrom<i64> for f64

fn lossy_from(src: i64) -> f64

impl LossyFrom<i8> for FixedI8<U0>

fn lossy_from(src: i8) -> FixedI8<U0>

impl LossyFrom<i8> for f32

fn lossy_from(src: i8) -> f32

impl LossyFrom<i8> for f64

fn lossy_from(src: i8) -> f64

impl LossyFrom<isize> for f32

fn lossy_from(src: isize) -> f32

impl LossyFrom<isize> for f64

fn lossy_from(src: isize) -> f64

impl LossyFrom<u128> for FixedU128<U0>

fn lossy_from(src: u128) -> FixedU128<U0>

impl LossyFrom<u128> for f32

fn lossy_from(src: u128) -> f32

impl LossyFrom<u128> for f64

fn lossy_from(src: u128) -> f64

impl LossyFrom<u16> for FixedU16<U0>

fn lossy_from(src: u16) -> FixedU16<U0>

impl LossyFrom<u16> for f32

fn lossy_from(src: u16) -> f32

impl LossyFrom<u16> for f64

fn lossy_from(src: u16) -> f64

impl LossyFrom<u32> for FixedU32<U0>

fn lossy_from(src: u32) -> FixedU32<U0>

impl LossyFrom<u32> for f32

fn lossy_from(src: u32) -> f32

impl LossyFrom<u32> for f64

fn lossy_from(src: u32) -> f64

impl LossyFrom<u64> for FixedU64<U0>

fn lossy_from(src: u64) -> FixedU64<U0>

impl LossyFrom<u64> for f32

fn lossy_from(src: u64) -> f32

impl LossyFrom<u64> for f64

fn lossy_from(src: u64) -> f64

impl LossyFrom<u8> for FixedU8<U0>

fn lossy_from(src: u8) -> FixedU8<U0>

impl LossyFrom<u8> for f32

fn lossy_from(src: u8) -> f32

impl LossyFrom<u8> for f64

fn lossy_from(src: u8) -> f64

impl LossyFrom<usize> for f32

fn lossy_from(src: usize) -> f32

impl LossyFrom<usize> for f64

fn lossy_from(src: usize) -> f64

impl<Frac> LossyFrom<FixedI128<Frac>> for f32 where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn lossy_from(src: FixedI128<Frac>) -> f32

impl<Frac> LossyFrom<FixedI128<Frac>> for f64 where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn lossy_from(src: FixedI128<Frac>) -> f64

impl<Frac> LossyFrom<FixedI16<Frac>> for f32 where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn lossy_from(src: FixedI16<Frac>) -> f32

impl<Frac> LossyFrom<FixedI16<Frac>> for f64 where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn lossy_from(src: FixedI16<Frac>) -> f64

impl<Frac> LossyFrom<FixedI32<Frac>> for f32 where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn lossy_from(src: FixedI32<Frac>) -> f32

impl<Frac> LossyFrom<FixedI32<Frac>> for f64 where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn lossy_from(src: FixedI32<Frac>) -> f64

impl<Frac> LossyFrom<FixedI64<Frac>> for f32 where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn lossy_from(src: FixedI64<Frac>) -> f32

impl<Frac> LossyFrom<FixedI64<Frac>> for f64 where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn lossy_from(src: FixedI64<Frac>) -> f64

impl<Frac> LossyFrom<FixedI8<Frac>> for f32 where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn lossy_from(src: FixedI8<Frac>) -> f32

impl<Frac> LossyFrom<FixedI8<Frac>> for f64 where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn lossy_from(src: FixedI8<Frac>) -> f64

impl<Frac> LossyFrom<FixedU128<Frac>> for f32 where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn lossy_from(src: FixedU128<Frac>) -> f32

impl<Frac> LossyFrom<FixedU128<Frac>> for f64 where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn lossy_from(src: FixedU128<Frac>) -> f64

impl<Frac> LossyFrom<FixedU16<Frac>> for f32 where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn lossy_from(src: FixedU16<Frac>) -> f32

impl<Frac> LossyFrom<FixedU16<Frac>> for f64 where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn lossy_from(src: FixedU16<Frac>) -> f64

impl<Frac> LossyFrom<FixedU32<Frac>> for f32 where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn lossy_from(src: FixedU32<Frac>) -> f32

impl<Frac> LossyFrom<FixedU32<Frac>> for f64 where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn lossy_from(src: FixedU32<Frac>) -> f64

impl<Frac> LossyFrom<FixedU64<Frac>> for f32 where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn lossy_from(src: FixedU64<Frac>) -> f32

impl<Frac> LossyFrom<FixedU64<Frac>> for f64 where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn lossy_from(src: FixedU64<Frac>) -> f64

impl<Frac> LossyFrom<FixedU8<Frac>> for f32 where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn lossy_from(src: FixedU8<Frac>) -> f32

impl<Frac> LossyFrom<FixedU8<Frac>> for f64 where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn lossy_from(src: FixedU8<Frac>) -> f64

impl<FracDst> LossyFrom<i16> for FixedI128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<U128 as Sub<U16>>::Output, Output = True>, 

fn lossy_from(src: i16) -> FixedI128<FracDst>

impl<FracDst> LossyFrom<i16> for FixedI32<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U16>>::Output, Output = True>, 

fn lossy_from(src: i16) -> FixedI32<FracDst>

impl<FracDst> LossyFrom<i16> for FixedI64<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsLessOrEqual<<U64 as Sub<U16>>::Output, Output = True>, 

fn lossy_from(src: i16) -> FixedI64<FracDst>

impl<FracDst> LossyFrom<i32> for FixedI128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<U128 as Sub<U32>>::Output, Output = True>, 

fn lossy_from(src: i32) -> FixedI128<FracDst>

impl<FracDst> LossyFrom<i32> for FixedI64<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsLessOrEqual<<U64 as Sub<U32>>::Output, Output = True>, 

fn lossy_from(src: i32) -> FixedI64<FracDst>

impl<FracDst> LossyFrom<i64> for FixedI128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<U128 as Sub<U64>>::Output, Output = True>, 

fn lossy_from(src: i64) -> FixedI128<FracDst>

impl<FracDst> LossyFrom<i8> for FixedI128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<U128 as Sub<U8>>::Output, Output = True>, 

fn lossy_from(src: i8) -> FixedI128<FracDst>

impl<FracDst> LossyFrom<i8> for FixedI16<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + IsLessOrEqual<<U16 as Sub<U8>>::Output, Output = True>, 

fn lossy_from(src: i8) -> FixedI16<FracDst>

impl<FracDst> LossyFrom<i8> for FixedI32<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U8>>::Output, Output = True>, 

fn lossy_from(src: i8) -> FixedI32<FracDst>

impl<FracDst> LossyFrom<i8> for FixedI64<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsLessOrEqual<<U64 as Sub<U8>>::Output, Output = True>, 

fn lossy_from(src: i8) -> FixedI64<FracDst>

impl<FracDst> LossyFrom<u16> for FixedI128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<<U128 as Sub<U16>>::Output as Sub<U1>>::Output, Output = True>, 

fn lossy_from(src: u16) -> FixedI128<FracDst>

impl<FracDst> LossyFrom<u16> for FixedI32<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<<U32 as Sub<U16>>::Output as Sub<U1>>::Output, Output = True>, 

fn lossy_from(src: u16) -> FixedI32<FracDst>

impl<FracDst> LossyFrom<u16> for FixedI64<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsLessOrEqual<<<U64 as Sub<U16>>::Output as Sub<U1>>::Output, Output = True>, 

fn lossy_from(src: u16) -> FixedI64<FracDst>

impl<FracDst> LossyFrom<u16> for FixedU128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<U128 as Sub<U16>>::Output, Output = True>, 

fn lossy_from(src: u16) -> FixedU128<FracDst>

impl<FracDst> LossyFrom<u16> for FixedU32<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U16>>::Output, Output = True>, 

fn lossy_from(src: u16) -> FixedU32<FracDst>

impl<FracDst> LossyFrom<u16> for FixedU64<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsLessOrEqual<<U64 as Sub<U16>>::Output, Output = True>, 

fn lossy_from(src: u16) -> FixedU64<FracDst>

impl<FracDst> LossyFrom<u32> for FixedI128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<<U128 as Sub<U32>>::Output as Sub<U1>>::Output, Output = True>, 

fn lossy_from(src: u32) -> FixedI128<FracDst>

impl<FracDst> LossyFrom<u32> for FixedI64<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsLessOrEqual<<<U64 as Sub<U32>>::Output as Sub<U1>>::Output, Output = True>, 

fn lossy_from(src: u32) -> FixedI64<FracDst>

impl<FracDst> LossyFrom<u32> for FixedU128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<U128 as Sub<U32>>::Output, Output = True>, 

fn lossy_from(src: u32) -> FixedU128<FracDst>

impl<FracDst> LossyFrom<u32> for FixedU64<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsLessOrEqual<<U64 as Sub<U32>>::Output, Output = True>, 

fn lossy_from(src: u32) -> FixedU64<FracDst>

impl<FracDst> LossyFrom<u64> for FixedI128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<<U128 as Sub<U64>>::Output as Sub<U1>>::Output, Output = True>, 

fn lossy_from(src: u64) -> FixedI128<FracDst>

impl<FracDst> LossyFrom<u64> for FixedU128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<U128 as Sub<U64>>::Output, Output = True>, 

fn lossy_from(src: u64) -> FixedU128<FracDst>

impl<FracDst> LossyFrom<u8> for FixedI128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<<U128 as Sub<U8>>::Output as Sub<U1>>::Output, Output = True>, 

fn lossy_from(src: u8) -> FixedI128<FracDst>

impl<FracDst> LossyFrom<u8> for FixedI16<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + IsLessOrEqual<<<U16 as Sub<U8>>::Output as Sub<U1>>::Output, Output = True>, 

fn lossy_from(src: u8) -> FixedI16<FracDst>

impl<FracDst> LossyFrom<u8> for FixedI32<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<<U32 as Sub<U8>>::Output as Sub<U1>>::Output, Output = True>, 

fn lossy_from(src: u8) -> FixedI32<FracDst>

impl<FracDst> LossyFrom<u8> for FixedI64<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsLessOrEqual<<<U64 as Sub<U8>>::Output as Sub<U1>>::Output, Output = True>, 

fn lossy_from(src: u8) -> FixedI64<FracDst>

impl<FracDst> LossyFrom<u8> for FixedU128<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsLessOrEqual<<U128 as Sub<U8>>::Output, Output = True>, 

fn lossy_from(src: u8) -> FixedU128<FracDst>

impl<FracDst> LossyFrom<u8> for FixedU16<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + IsLessOrEqual<<U16 as Sub<U8>>::Output, Output = True>, 

fn lossy_from(src: u8) -> FixedU16<FracDst>

impl<FracDst> LossyFrom<u8> for FixedU32<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U8>>::Output, Output = True>, 

fn lossy_from(src: u8) -> FixedU32<FracDst>

impl<FracDst> LossyFrom<u8> for FixedU64<FracDst> where
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsLessOrEqual<<U64 as Sub<U8>>::Output, Output = True>, 

fn lossy_from(src: u8) -> FixedU64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI128<FracSrc>> for FixedI128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U128, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> FixedI128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI128<FracSrc>> for FixedI16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U128, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> FixedI16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI128<FracSrc>> for FixedI32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> FixedI32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI128<FracSrc>> for FixedI64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U128, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> FixedI64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI128<FracSrc>> for FixedI8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U128, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> FixedI8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI16<FracSrc>> for FixedI128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> FixedI128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI16<FracSrc>> for FixedI16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> FixedI16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI16<FracSrc>> for FixedI32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> FixedI32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI16<FracSrc>> for FixedI64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> FixedI64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI16<FracSrc>> for FixedI8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> FixedI8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI32<FracSrc>> for FixedI128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> FixedI128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI32<FracSrc>> for FixedI16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> FixedI16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI32<FracSrc>> for FixedI32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> FixedI32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI32<FracSrc>> for FixedI64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> FixedI64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI32<FracSrc>> for FixedI8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> FixedI8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI64<FracSrc>> for FixedI128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U64, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> FixedI128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI64<FracSrc>> for FixedI16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U64, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> FixedI16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI64<FracSrc>> for FixedI32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> FixedI32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI64<FracSrc>> for FixedI64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U64, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> FixedI64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI64<FracSrc>> for FixedI8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U64, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> FixedI8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI8<FracSrc>> for FixedI128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U8, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> FixedI128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI8<FracSrc>> for FixedI16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U8, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> FixedI16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI8<FracSrc>> for FixedI32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> FixedI32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI8<FracSrc>> for FixedI64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U8, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> FixedI64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedI8<FracSrc>> for FixedI8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U8, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> FixedI8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedI128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<<U128 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> FixedI128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedI16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<<U128 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> FixedI16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedI32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U128 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> FixedI32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedI64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<<U128 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> FixedI64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedI8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<<U128 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> FixedI8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedU128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U128, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> FixedU128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedU16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U128, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> FixedU16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedU32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> FixedU32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedU64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U128, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> FixedU64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedU8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U128, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> FixedU8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedI128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<<U16 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> FixedI128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedI16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<<U16 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> FixedI16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedI32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U16 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> FixedI32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedI64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<<U16 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> FixedI64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedI8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<<U16 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> FixedI8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedU128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> FixedU128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedU16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> FixedU16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedU32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> FixedU32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedU64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> FixedU64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedU8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> FixedU8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedI128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> FixedI128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedI16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> FixedI16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedI32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> FixedI32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedI64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> FixedI64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedI8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> FixedI8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedU128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> FixedU128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedU16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> FixedU16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedU32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> FixedU32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedU64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> FixedU64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedU8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> FixedU8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedI128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<<U64 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> FixedI128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedI16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<<U64 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> FixedI16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedI32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U64 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> FixedI32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedI64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<<U64 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> FixedI64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedI8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<<U64 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> FixedI8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedU128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U64, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> FixedU128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedU16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U64, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> FixedU16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedU32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> FixedU32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedU64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U64, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> FixedU64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedU8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U64, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> FixedU8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedI128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<<U8 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> FixedI128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedI16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<<U8 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> FixedI16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedI32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U8 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> FixedI32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedI64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<<U8 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> FixedI64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedI8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<<U8 as Add<U1>>::Output, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> FixedI8<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedU128<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U128, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U8, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> FixedU128<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedU16<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U8, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> FixedU16<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedU32<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> FixedU32<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedU64<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U64, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U8, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> FixedU64<FracDst>

impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedU8<FracDst> where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U8, Output = FracSrcP>,
    FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U8, Output = FracDstP>,
    FracSrcP: Unsigned,
    FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> FixedU8<FracDst>

impl<FracSrc, FracSrcP> LossyFrom<FixedI128<FracSrc>> for i128 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> i128

impl<FracSrc, FracSrcP> LossyFrom<FixedI128<FracSrc>> for i16 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> i16

impl<FracSrc, FracSrcP> LossyFrom<FixedI128<FracSrc>> for i32 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> i32

impl<FracSrc, FracSrcP> LossyFrom<FixedI128<FracSrc>> for i64 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> i64

impl<FracSrc, FracSrcP> LossyFrom<FixedI128<FracSrc>> for i8 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> i8

impl<FracSrc, FracSrcP> LossyFrom<FixedI128<FracSrc>> for isize where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> isize

impl<FracSrc, FracSrcP> LossyFrom<FixedI16<FracSrc>> for i128 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> i128

impl<FracSrc, FracSrcP> LossyFrom<FixedI16<FracSrc>> for i16 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> i16

impl<FracSrc, FracSrcP> LossyFrom<FixedI16<FracSrc>> for i32 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> i32

impl<FracSrc, FracSrcP> LossyFrom<FixedI16<FracSrc>> for i64 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> i64

impl<FracSrc, FracSrcP> LossyFrom<FixedI16<FracSrc>> for i8 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> i8

impl<FracSrc, FracSrcP> LossyFrom<FixedI16<FracSrc>> for isize where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> isize

impl<FracSrc, FracSrcP> LossyFrom<FixedI32<FracSrc>> for i128 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> i128

impl<FracSrc, FracSrcP> LossyFrom<FixedI32<FracSrc>> for i16 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> i16

impl<FracSrc, FracSrcP> LossyFrom<FixedI32<FracSrc>> for i32 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> i32

impl<FracSrc, FracSrcP> LossyFrom<FixedI32<FracSrc>> for i64 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> i64

impl<FracSrc, FracSrcP> LossyFrom<FixedI32<FracSrc>> for i8 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> i8

impl<FracSrc, FracSrcP> LossyFrom<FixedI32<FracSrc>> for isize where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> isize

impl<FracSrc, FracSrcP> LossyFrom<FixedI64<FracSrc>> for i128 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> i128

impl<FracSrc, FracSrcP> LossyFrom<FixedI64<FracSrc>> for i16 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> i16

impl<FracSrc, FracSrcP> LossyFrom<FixedI64<FracSrc>> for i32 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> i32

impl<FracSrc, FracSrcP> LossyFrom<FixedI64<FracSrc>> for i64 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> i64

impl<FracSrc, FracSrcP> LossyFrom<FixedI64<FracSrc>> for i8 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> i8

impl<FracSrc, FracSrcP> LossyFrom<FixedI64<FracSrc>> for isize where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> isize

impl<FracSrc, FracSrcP> LossyFrom<FixedI8<FracSrc>> for i128 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> i128

impl<FracSrc, FracSrcP> LossyFrom<FixedI8<FracSrc>> for i16 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> i16

impl<FracSrc, FracSrcP> LossyFrom<FixedI8<FracSrc>> for i32 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> i32

impl<FracSrc, FracSrcP> LossyFrom<FixedI8<FracSrc>> for i64 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> i64

impl<FracSrc, FracSrcP> LossyFrom<FixedI8<FracSrc>> for i8 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> i8

impl<FracSrc, FracSrcP> LossyFrom<FixedI8<FracSrc>> for isize where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> isize

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for i128 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U128 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> i128

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for i16 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U128 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> i16

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for i32 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U128 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> i32

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for i64 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U128 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> i64

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for i8 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U128 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> i8

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for isize where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U128 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> isize

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for u128 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> u128

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for u16 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> u16

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for u32 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> u32

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for u64 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> u64

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for u8 where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> u8

impl<FracSrc, FracSrcP> LossyFrom<FixedU128<FracSrc>> for usize where
    FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U128: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> usize

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for i128 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U16 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> i128

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for i16 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U16 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> i16

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for i32 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U16 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> i32

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for i64 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U16 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> i64

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for i8 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U16 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> i8

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for isize where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U16 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> isize

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for u128 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> u128

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for u16 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> u16

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for u32 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> u32

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for u64 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> u64

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for u8 where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> u8

impl<FracSrc, FracSrcP> LossyFrom<FixedU16<FracSrc>> for usize where
    FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U16: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> usize

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for i128 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> i128

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for i16 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> i16

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for i32 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> i32

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for i64 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> i64

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for i8 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> i8

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for isize where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> isize

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for u128 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> u128

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for u16 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> u16

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for u32 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> u32

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for u64 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> u64

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for u8 where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> u8

impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for usize where
    FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U32: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> usize

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for i128 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U64 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> i128

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for i16 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U64 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> i16

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for i32 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U64 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> i32

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for i64 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U64 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> i64

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for i8 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U64 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> i8

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for isize where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U64 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> isize

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for u128 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> u128

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for u16 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> u16

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for u32 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> u32

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for u64 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> u64

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for u8 where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> u8

impl<FracSrc, FracSrcP> LossyFrom<FixedU64<FracSrc>> for usize where
    FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U64: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> usize

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for i128 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U8 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> i128

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for i16 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U8 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> i16

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for i32 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U8 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> i32

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for i64 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U8 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> i64

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for i8 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U8 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> i8

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for isize where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    <U8 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> isize

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for u128 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U128, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> u128

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for u16 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> u16

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for u32 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> u32

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for u64 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U64, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> u64

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for u8 where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U8, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> u8

impl<FracSrc, FracSrcP> LossyFrom<FixedU8<FracSrc>> for usize where
    FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U16, Output = FracSrcP>,
    FracSrcP: Unsigned,
    U8: IsLessOrEqual<FracSrcP, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> usize

Loading content...