Trait metron::FromUnit

pub trait FromUnit<N, U> where
    U: Unit, {
    type Output;
    fn from_unit(num: N) -> Self::Output;
}

Measurement conversion from some unit.

Associated Types

type Output

Required methods

fn from_unit(num: N) -> Self::Output

Implementors

impl<N> FromUnit<N, Chain> for Chain

type Output = N

pub fn from_unit(num: N) -> <Chain as FromUnit<N, Chain>>::Output

impl<N> FromUnit<N, Chain> for Furlong where
    N: Div<f32, Output = N>, 

type Output = N

pub fn from_unit(num: N) -> N

impl<N> FromUnit<N, Feet> for Feet

type Output = N

pub fn from_unit(num: N) -> <Feet as FromUnit<N, Feet>>::Output

impl<N> FromUnit<N, Feet> for Thou where
    N: Mul<f32, Output = N>, 

type Output = N

pub fn from_unit(num: N) -> N

impl<N> FromUnit<N, Feet> for Yard where
    N: Div<f32, Output = N>, 

type Output = N

pub fn from_unit(num: N) -> N

impl<N> FromUnit<N, Furlong> for Furlong

type Output = N

pub fn from_unit(num: N) -> <Furlong as FromUnit<N, Furlong>>::Output

impl<N> FromUnit<N, Furlong> for Mile where
    N: Div<f32, Output = N>, 

type Output = N

pub fn from_unit(num: N) -> N

impl<N> FromUnit<N, Inch> for Feet where
    N: Div<f32, Output = N>, 

type Output = N

pub fn from_unit(num: N) -> N

impl<N> FromUnit<N, Inch> for Inch

type Output = N

pub fn from_unit(num: N) -> <Inch as FromUnit<N, Inch>>::Output

impl<N> FromUnit<N, Inch> for Thou where
    N: Mul<f32, Output = N>, 

type Output = N

pub fn from_unit(num: N) -> N

impl<N> FromUnit<N, League> for League

type Output = N

pub fn from_unit(num: N) -> <League as FromUnit<N, League>>::Output

impl<N> FromUnit<N, Mile> for League where
    N: Div<f32, Output = N>, 

type Output = N

pub fn from_unit(num: N) -> N

impl<N> FromUnit<N, Mile> for Mile

type Output = N

pub fn from_unit(num: N) -> <Mile as FromUnit<N, Mile>>::Output

impl<N> FromUnit<N, Thou> for Feet where
    N: Div<f32, Output = N>, 

type Output = N

pub fn from_unit(num: N) -> N

impl<N> FromUnit<N, Thou> for Inch where
    N: Div<f32, Output = N>, 

type Output = N

pub fn from_unit(num: N) -> N

impl<N> FromUnit<N, Thou> for Thou

type Output = N

pub fn from_unit(num: N) -> <Thou as FromUnit<N, Thou>>::Output

impl<N> FromUnit<N, Yard> for Chain where
    N: Div<f32, Output = N>, 

type Output = N

pub fn from_unit(num: N) -> N

impl<N> FromUnit<N, Yard> for Yard

type Output = N

pub fn from_unit(num: N) -> <Yard as FromUnit<N, Yard>>::Output

impl<N> FromUnit<N, Ampere> for Ampere

type Output = N

pub fn from_unit(num: N) -> <Ampere as FromUnit<N, Ampere>>::Output

impl<N> FromUnit<N, AttoAmpere> for AttoAmpere

type Output = N

pub fn from_unit(num: N) -> <AttoAmpere as FromUnit<N, AttoAmpere>>::Output

impl<N> FromUnit<N, CentiAmpere> for CentiAmpere

type Output = N

pub fn from_unit(num: N) -> <CentiAmpere as FromUnit<N, CentiAmpere>>::Output

impl<N> FromUnit<N, DeciAmpere> for DeciAmpere

type Output = N

pub fn from_unit(num: N) -> <DeciAmpere as FromUnit<N, DeciAmpere>>::Output

impl<N> FromUnit<N, DekaAmpere> for DekaAmpere

type Output = N

pub fn from_unit(num: N) -> <DekaAmpere as FromUnit<N, DekaAmpere>>::Output

impl<N> FromUnit<N, ExaAmpere> for ExaAmpere

type Output = N

pub fn from_unit(num: N) -> <ExaAmpere as FromUnit<N, ExaAmpere>>::Output

impl<N> FromUnit<N, FemtoAmpere> for FemtoAmpere

type Output = N

pub fn from_unit(num: N) -> <FemtoAmpere as FromUnit<N, FemtoAmpere>>::Output

impl<N> FromUnit<N, GigaAmpere> for GigaAmpere

type Output = N

pub fn from_unit(num: N) -> <GigaAmpere as FromUnit<N, GigaAmpere>>::Output

impl<N> FromUnit<N, HectoAmpere> for HectoAmpere

type Output = N

pub fn from_unit(num: N) -> <HectoAmpere as FromUnit<N, HectoAmpere>>::Output

impl<N> FromUnit<N, KiloAmpere> for KiloAmpere

type Output = N

pub fn from_unit(num: N) -> <KiloAmpere as FromUnit<N, KiloAmpere>>::Output

impl<N> FromUnit<N, MegaAmpere> for MegaAmpere

type Output = N

pub fn from_unit(num: N) -> <MegaAmpere as FromUnit<N, MegaAmpere>>::Output

impl<N> FromUnit<N, MicroAmpere> for MicroAmpere

type Output = N

pub fn from_unit(num: N) -> <MicroAmpere as FromUnit<N, MicroAmpere>>::Output

impl<N> FromUnit<N, MilliAmpere> for MilliAmpere

type Output = N

pub fn from_unit(num: N) -> <MilliAmpere as FromUnit<N, MilliAmpere>>::Output

impl<N> FromUnit<N, NanoAmpere> for NanoAmpere

type Output = N

pub fn from_unit(num: N) -> <NanoAmpere as FromUnit<N, NanoAmpere>>::Output

impl<N> FromUnit<N, PetaAmpere> for PetaAmpere

type Output = N

pub fn from_unit(num: N) -> <PetaAmpere as FromUnit<N, PetaAmpere>>::Output

impl<N> FromUnit<N, PicoAmpere> for PicoAmpere

type Output = N

pub fn from_unit(num: N) -> <PicoAmpere as FromUnit<N, PicoAmpere>>::Output

impl<N> FromUnit<N, TeraAmpere> for TeraAmpere

type Output = N

pub fn from_unit(num: N) -> <TeraAmpere as FromUnit<N, TeraAmpere>>::Output

impl<N> FromUnit<N, YoctoAmpere> for YoctoAmpere

type Output = N

pub fn from_unit(num: N) -> <YoctoAmpere as FromUnit<N, YoctoAmpere>>::Output

impl<N> FromUnit<N, YottaAmpere> for YottaAmpere

type Output = N

pub fn from_unit(num: N) -> <YottaAmpere as FromUnit<N, YottaAmpere>>::Output

impl<N> FromUnit<N, ZeptoAmpere> for ZeptoAmpere

type Output = N

pub fn from_unit(num: N) -> <ZeptoAmpere as FromUnit<N, ZeptoAmpere>>::Output

impl<N> FromUnit<N, ZettaAmpere> for ZettaAmpere

type Output = N

pub fn from_unit(num: N) -> <ZettaAmpere as FromUnit<N, ZettaAmpere>>::Output

impl<N> FromUnit<N, AttoCandela> for AttoCandela

type Output = N

pub fn from_unit(num: N) -> <AttoCandela as FromUnit<N, AttoCandela>>::Output

impl<N> FromUnit<N, Candela> for Candela

type Output = N

pub fn from_unit(num: N) -> <Candela as FromUnit<N, Candela>>::Output

impl<N> FromUnit<N, CentiCandela> for CentiCandela

type Output = N

pub fn from_unit(num: N) -> <CentiCandela as FromUnit<N, CentiCandela>>::Output

impl<N> FromUnit<N, DeciCandela> for DeciCandela

type Output = N

pub fn from_unit(num: N) -> <DeciCandela as FromUnit<N, DeciCandela>>::Output

impl<N> FromUnit<N, DekaCandela> for DekaCandela

type Output = N

pub fn from_unit(num: N) -> <DekaCandela as FromUnit<N, DekaCandela>>::Output

impl<N> FromUnit<N, ExaCandela> for ExaCandela

type Output = N

pub fn from_unit(num: N) -> <ExaCandela as FromUnit<N, ExaCandela>>::Output

impl<N> FromUnit<N, FemtoCandela> for FemtoCandela

type Output = N

pub fn from_unit(num: N) -> <FemtoCandela as FromUnit<N, FemtoCandela>>::Output

impl<N> FromUnit<N, GigaCandela> for GigaCandela

type Output = N

pub fn from_unit(num: N) -> <GigaCandela as FromUnit<N, GigaCandela>>::Output

impl<N> FromUnit<N, HectoCandela> for HectoCandela

type Output = N

pub fn from_unit(num: N) -> <HectoCandela as FromUnit<N, HectoCandela>>::Output

impl<N> FromUnit<N, KiloCandela> for KiloCandela

type Output = N

pub fn from_unit(num: N) -> <KiloCandela as FromUnit<N, KiloCandela>>::Output

impl<N> FromUnit<N, MegaCandela> for MegaCandela

type Output = N

pub fn from_unit(num: N) -> <MegaCandela as FromUnit<N, MegaCandela>>::Output

impl<N> FromUnit<N, MicroCandela> for MicroCandela

type Output = N

pub fn from_unit(num: N) -> <MicroCandela as FromUnit<N, MicroCandela>>::Output

impl<N> FromUnit<N, MilliCandela> for MilliCandela

type Output = N

pub fn from_unit(num: N) -> <MilliCandela as FromUnit<N, MilliCandela>>::Output

impl<N> FromUnit<N, NanoCandela> for NanoCandela

type Output = N

pub fn from_unit(num: N) -> <NanoCandela as FromUnit<N, NanoCandela>>::Output

impl<N> FromUnit<N, PetaCandela> for PetaCandela

type Output = N

pub fn from_unit(num: N) -> <PetaCandela as FromUnit<N, PetaCandela>>::Output

impl<N> FromUnit<N, PicoCandela> for PicoCandela

type Output = N

pub fn from_unit(num: N) -> <PicoCandela as FromUnit<N, PicoCandela>>::Output

impl<N> FromUnit<N, TeraCandela> for TeraCandela

type Output = N

pub fn from_unit(num: N) -> <TeraCandela as FromUnit<N, TeraCandela>>::Output

impl<N> FromUnit<N, YoctoCandela> for YoctoCandela

type Output = N

pub fn from_unit(num: N) -> <YoctoCandela as FromUnit<N, YoctoCandela>>::Output

impl<N> FromUnit<N, YottaCandela> for YottaCandela

type Output = N

pub fn from_unit(num: N) -> <YottaCandela as FromUnit<N, YottaCandela>>::Output

impl<N> FromUnit<N, ZeptoCandela> for ZeptoCandela

type Output = N

pub fn from_unit(num: N) -> <ZeptoCandela as FromUnit<N, ZeptoCandela>>::Output

impl<N> FromUnit<N, ZettaCandela> for ZettaCandela

type Output = N

pub fn from_unit(num: N) -> <ZettaCandela as FromUnit<N, ZettaCandela>>::Output

impl<N> FromUnit<N, AttoKelvin> for AttoKelvin

type Output = N

pub fn from_unit(num: N) -> <AttoKelvin as FromUnit<N, AttoKelvin>>::Output

impl<N> FromUnit<N, CentiKelvin> for CentiKelvin

type Output = N

pub fn from_unit(num: N) -> <CentiKelvin as FromUnit<N, CentiKelvin>>::Output

impl<N> FromUnit<N, DeciKelvin> for DeciKelvin

type Output = N

pub fn from_unit(num: N) -> <DeciKelvin as FromUnit<N, DeciKelvin>>::Output

impl<N> FromUnit<N, DekaKelvin> for DekaKelvin

type Output = N

pub fn from_unit(num: N) -> <DekaKelvin as FromUnit<N, DekaKelvin>>::Output

impl<N> FromUnit<N, ExaKelvin> for ExaKelvin

type Output = N

pub fn from_unit(num: N) -> <ExaKelvin as FromUnit<N, ExaKelvin>>::Output

impl<N> FromUnit<N, FemtoKelvin> for FemtoKelvin

type Output = N

pub fn from_unit(num: N) -> <FemtoKelvin as FromUnit<N, FemtoKelvin>>::Output

impl<N> FromUnit<N, GigaKelvin> for GigaKelvin

type Output = N

pub fn from_unit(num: N) -> <GigaKelvin as FromUnit<N, GigaKelvin>>::Output

impl<N> FromUnit<N, HectoKelvin> for HectoKelvin

type Output = N

pub fn from_unit(num: N) -> <HectoKelvin as FromUnit<N, HectoKelvin>>::Output

impl<N> FromUnit<N, Kelvin> for Kelvin

type Output = N

pub fn from_unit(num: N) -> <Kelvin as FromUnit<N, Kelvin>>::Output

impl<N> FromUnit<N, KiloKelvin> for KiloKelvin

type Output = N

pub fn from_unit(num: N) -> <KiloKelvin as FromUnit<N, KiloKelvin>>::Output

impl<N> FromUnit<N, MegaKelvin> for MegaKelvin

type Output = N

pub fn from_unit(num: N) -> <MegaKelvin as FromUnit<N, MegaKelvin>>::Output

impl<N> FromUnit<N, MicroKelvin> for MicroKelvin

type Output = N

pub fn from_unit(num: N) -> <MicroKelvin as FromUnit<N, MicroKelvin>>::Output

impl<N> FromUnit<N, MilliKelvin> for MilliKelvin

type Output = N

pub fn from_unit(num: N) -> <MilliKelvin as FromUnit<N, MilliKelvin>>::Output

impl<N> FromUnit<N, NanoKelvin> for NanoKelvin

type Output = N

pub fn from_unit(num: N) -> <NanoKelvin as FromUnit<N, NanoKelvin>>::Output

impl<N> FromUnit<N, PetaKelvin> for PetaKelvin

type Output = N

pub fn from_unit(num: N) -> <PetaKelvin as FromUnit<N, PetaKelvin>>::Output

impl<N> FromUnit<N, PicoKelvin> for PicoKelvin

type Output = N

pub fn from_unit(num: N) -> <PicoKelvin as FromUnit<N, PicoKelvin>>::Output

impl<N> FromUnit<N, TeraKelvin> for TeraKelvin

type Output = N

pub fn from_unit(num: N) -> <TeraKelvin as FromUnit<N, TeraKelvin>>::Output

impl<N> FromUnit<N, YoctoKelvin> for YoctoKelvin

type Output = N

pub fn from_unit(num: N) -> <YoctoKelvin as FromUnit<N, YoctoKelvin>>::Output

impl<N> FromUnit<N, YottaKelvin> for YottaKelvin

type Output = N

pub fn from_unit(num: N) -> <YottaKelvin as FromUnit<N, YottaKelvin>>::Output

impl<N> FromUnit<N, ZeptoKelvin> for ZeptoKelvin

type Output = N

pub fn from_unit(num: N) -> <ZeptoKelvin as FromUnit<N, ZeptoKelvin>>::Output

impl<N> FromUnit<N, ZettaKelvin> for ZettaKelvin

type Output = N

pub fn from_unit(num: N) -> <ZettaKelvin as FromUnit<N, ZettaKelvin>>::Output

impl<N> FromUnit<N, AttoGram> for AttoGram

type Output = N

pub fn from_unit(num: N) -> <AttoGram as FromUnit<N, AttoGram>>::Output

impl<N> FromUnit<N, CentiGram> for CentiGram

type Output = N

pub fn from_unit(num: N) -> <CentiGram as FromUnit<N, CentiGram>>::Output

impl<N> FromUnit<N, DeciGram> for DeciGram

type Output = N

pub fn from_unit(num: N) -> <DeciGram as FromUnit<N, DeciGram>>::Output

impl<N> FromUnit<N, DekaGram> for DekaGram

type Output = N

pub fn from_unit(num: N) -> <DekaGram as FromUnit<N, DekaGram>>::Output

impl<N> FromUnit<N, ExaGram> for ExaGram

type Output = N

pub fn from_unit(num: N) -> <ExaGram as FromUnit<N, ExaGram>>::Output

impl<N> FromUnit<N, FemtoGram> for FemtoGram

type Output = N

pub fn from_unit(num: N) -> <FemtoGram as FromUnit<N, FemtoGram>>::Output

impl<N> FromUnit<N, GigaGram> for GigaGram

type Output = N

pub fn from_unit(num: N) -> <GigaGram as FromUnit<N, GigaGram>>::Output

impl<N> FromUnit<N, Gram> for Gram

type Output = N

pub fn from_unit(num: N) -> <Gram as FromUnit<N, Gram>>::Output

impl<N> FromUnit<N, HectoGram> for HectoGram

type Output = N

pub fn from_unit(num: N) -> <HectoGram as FromUnit<N, HectoGram>>::Output

impl<N> FromUnit<N, KiloGram> for KiloGram

type Output = N

pub fn from_unit(num: N) -> <KiloGram as FromUnit<N, KiloGram>>::Output

impl<N> FromUnit<N, MegaGram> for MegaGram

type Output = N

pub fn from_unit(num: N) -> <MegaGram as FromUnit<N, MegaGram>>::Output

impl<N> FromUnit<N, MicroGram> for MicroGram

type Output = N

pub fn from_unit(num: N) -> <MicroGram as FromUnit<N, MicroGram>>::Output

impl<N> FromUnit<N, MilliGram> for MilliGram

type Output = N

pub fn from_unit(num: N) -> <MilliGram as FromUnit<N, MilliGram>>::Output

impl<N> FromUnit<N, NanoGram> for NanoGram

type Output = N

pub fn from_unit(num: N) -> <NanoGram as FromUnit<N, NanoGram>>::Output

impl<N> FromUnit<N, PetaGram> for PetaGram

type Output = N

pub fn from_unit(num: N) -> <PetaGram as FromUnit<N, PetaGram>>::Output

impl<N> FromUnit<N, PicoGram> for PicoGram

type Output = N

pub fn from_unit(num: N) -> <PicoGram as FromUnit<N, PicoGram>>::Output

impl<N> FromUnit<N, TeraGram> for TeraGram

type Output = N

pub fn from_unit(num: N) -> <TeraGram as FromUnit<N, TeraGram>>::Output

impl<N> FromUnit<N, YoctoGram> for YoctoGram

type Output = N

pub fn from_unit(num: N) -> <YoctoGram as FromUnit<N, YoctoGram>>::Output

impl<N> FromUnit<N, YottaGram> for YottaGram

type Output = N

pub fn from_unit(num: N) -> <YottaGram as FromUnit<N, YottaGram>>::Output

impl<N> FromUnit<N, ZeptoGram> for ZeptoGram

type Output = N

pub fn from_unit(num: N) -> <ZeptoGram as FromUnit<N, ZeptoGram>>::Output

impl<N> FromUnit<N, ZettaGram> for ZettaGram

type Output = N

pub fn from_unit(num: N) -> <ZettaGram as FromUnit<N, ZettaGram>>::Output

impl<N> FromUnit<N, AttoMetre> for AttoMetre

type Output = N

pub fn from_unit(num: N) -> <AttoMetre as FromUnit<N, AttoMetre>>::Output

impl<N> FromUnit<N, CentiMetre> for CentiMetre

type Output = N

pub fn from_unit(num: N) -> <CentiMetre as FromUnit<N, CentiMetre>>::Output

impl<N> FromUnit<N, DeciMetre> for DeciMetre

type Output = N

pub fn from_unit(num: N) -> <DeciMetre as FromUnit<N, DeciMetre>>::Output

impl<N> FromUnit<N, DekaMetre> for DekaMetre

type Output = N

pub fn from_unit(num: N) -> <DekaMetre as FromUnit<N, DekaMetre>>::Output

impl<N> FromUnit<N, ExaMetre> for ExaMetre

type Output = N

pub fn from_unit(num: N) -> <ExaMetre as FromUnit<N, ExaMetre>>::Output

impl<N> FromUnit<N, FemtoMetre> for FemtoMetre

type Output = N

pub fn from_unit(num: N) -> <FemtoMetre as FromUnit<N, FemtoMetre>>::Output

impl<N> FromUnit<N, GigaMetre> for GigaMetre

type Output = N

pub fn from_unit(num: N) -> <GigaMetre as FromUnit<N, GigaMetre>>::Output

impl<N> FromUnit<N, HectoMetre> for HectoMetre

type Output = N

pub fn from_unit(num: N) -> <HectoMetre as FromUnit<N, HectoMetre>>::Output

impl<N> FromUnit<N, KiloMetre> for Length where
    <Length as Quantity>::BaseUnit: FromUnit<N, KiloMetre>, 

type Output = <<Length as Quantity>::BaseUnit as FromUnit<N, KiloMetre>>::Output

pub fn from_unit(
    num: N
) -> <<Length as Quantity>::BaseUnit as FromUnit<N, KiloMetre>>::Output

impl<N> FromUnit<N, KiloMetre> for KiloMetre

type Output = N

pub fn from_unit(num: N) -> <KiloMetre as FromUnit<N, KiloMetre>>::Output

impl<N> FromUnit<N, MegaMetre> for MegaMetre

type Output = N

pub fn from_unit(num: N) -> <MegaMetre as FromUnit<N, MegaMetre>>::Output

impl<N> FromUnit<N, Metre> for Length where
    <Length as Quantity>::BaseUnit: FromUnit<N, Metre>, 

type Output = <<Length as Quantity>::BaseUnit as FromUnit<N, Metre>>::Output

pub fn from_unit(
    num: N
) -> <<Length as Quantity>::BaseUnit as FromUnit<N, Metre>>::Output

impl<N> FromUnit<N, Metre> for Metre

type Output = N

pub fn from_unit(num: N) -> <Metre as FromUnit<N, Metre>>::Output

impl<N> FromUnit<N, MicroMetre> for MicroMetre

type Output = N

pub fn from_unit(num: N) -> <MicroMetre as FromUnit<N, MicroMetre>>::Output

impl<N> FromUnit<N, MilliMetre> for MilliMetre

type Output = N

pub fn from_unit(num: N) -> <MilliMetre as FromUnit<N, MilliMetre>>::Output

impl<N> FromUnit<N, NanoMetre> for NanoMetre

type Output = N

pub fn from_unit(num: N) -> <NanoMetre as FromUnit<N, NanoMetre>>::Output

impl<N> FromUnit<N, PetaMetre> for PetaMetre

type Output = N

pub fn from_unit(num: N) -> <PetaMetre as FromUnit<N, PetaMetre>>::Output

impl<N> FromUnit<N, PicoMetre> for PicoMetre

type Output = N

pub fn from_unit(num: N) -> <PicoMetre as FromUnit<N, PicoMetre>>::Output

impl<N> FromUnit<N, TeraMetre> for TeraMetre

type Output = N

pub fn from_unit(num: N) -> <TeraMetre as FromUnit<N, TeraMetre>>::Output

impl<N> FromUnit<N, YoctoMetre> for YoctoMetre

type Output = N

pub fn from_unit(num: N) -> <YoctoMetre as FromUnit<N, YoctoMetre>>::Output

impl<N> FromUnit<N, YottaMetre> for YottaMetre

type Output = N

pub fn from_unit(num: N) -> <YottaMetre as FromUnit<N, YottaMetre>>::Output

impl<N> FromUnit<N, ZeptoMetre> for ZeptoMetre

type Output = N

pub fn from_unit(num: N) -> <ZeptoMetre as FromUnit<N, ZeptoMetre>>::Output

impl<N> FromUnit<N, ZettaMetre> for ZettaMetre

type Output = N

pub fn from_unit(num: N) -> <ZettaMetre as FromUnit<N, ZettaMetre>>::Output

impl<N> FromUnit<N, AttoMole> for AttoMole

type Output = N

pub fn from_unit(num: N) -> <AttoMole as FromUnit<N, AttoMole>>::Output

impl<N> FromUnit<N, CentiMole> for CentiMole

type Output = N

pub fn from_unit(num: N) -> <CentiMole as FromUnit<N, CentiMole>>::Output

impl<N> FromUnit<N, DeciMole> for DeciMole

type Output = N

pub fn from_unit(num: N) -> <DeciMole as FromUnit<N, DeciMole>>::Output

impl<N> FromUnit<N, DekaMole> for DekaMole

type Output = N

pub fn from_unit(num: N) -> <DekaMole as FromUnit<N, DekaMole>>::Output

impl<N> FromUnit<N, ExaMole> for ExaMole

type Output = N

pub fn from_unit(num: N) -> <ExaMole as FromUnit<N, ExaMole>>::Output

impl<N> FromUnit<N, FemtoMole> for FemtoMole

type Output = N

pub fn from_unit(num: N) -> <FemtoMole as FromUnit<N, FemtoMole>>::Output

impl<N> FromUnit<N, GigaMole> for GigaMole

type Output = N

pub fn from_unit(num: N) -> <GigaMole as FromUnit<N, GigaMole>>::Output

impl<N> FromUnit<N, HectoMole> for HectoMole

type Output = N

pub fn from_unit(num: N) -> <HectoMole as FromUnit<N, HectoMole>>::Output

impl<N> FromUnit<N, KiloMole> for KiloMole

type Output = N

pub fn from_unit(num: N) -> <KiloMole as FromUnit<N, KiloMole>>::Output

impl<N> FromUnit<N, MegaMole> for MegaMole

type Output = N

pub fn from_unit(num: N) -> <MegaMole as FromUnit<N, MegaMole>>::Output

impl<N> FromUnit<N, MicroMole> for MicroMole

type Output = N

pub fn from_unit(num: N) -> <MicroMole as FromUnit<N, MicroMole>>::Output

impl<N> FromUnit<N, MilliMole> for MilliMole

type Output = N

pub fn from_unit(num: N) -> <MilliMole as FromUnit<N, MilliMole>>::Output

impl<N> FromUnit<N, Mole> for Mole

type Output = N

pub fn from_unit(num: N) -> <Mole as FromUnit<N, Mole>>::Output

impl<N> FromUnit<N, NanoMole> for NanoMole

type Output = N

pub fn from_unit(num: N) -> <NanoMole as FromUnit<N, NanoMole>>::Output

impl<N> FromUnit<N, PetaMole> for PetaMole

type Output = N

pub fn from_unit(num: N) -> <PetaMole as FromUnit<N, PetaMole>>::Output

impl<N> FromUnit<N, PicoMole> for PicoMole

type Output = N

pub fn from_unit(num: N) -> <PicoMole as FromUnit<N, PicoMole>>::Output

impl<N> FromUnit<N, TeraMole> for TeraMole

type Output = N

pub fn from_unit(num: N) -> <TeraMole as FromUnit<N, TeraMole>>::Output

impl<N> FromUnit<N, YoctoMole> for YoctoMole

type Output = N

pub fn from_unit(num: N) -> <YoctoMole as FromUnit<N, YoctoMole>>::Output

impl<N> FromUnit<N, YottaMole> for YottaMole

type Output = N

pub fn from_unit(num: N) -> <YottaMole as FromUnit<N, YottaMole>>::Output

impl<N> FromUnit<N, ZeptoMole> for ZeptoMole

type Output = N

pub fn from_unit(num: N) -> <ZeptoMole as FromUnit<N, ZeptoMole>>::Output

impl<N> FromUnit<N, ZettaMole> for ZettaMole

type Output = N

pub fn from_unit(num: N) -> <ZettaMole as FromUnit<N, ZettaMole>>::Output

impl<N> FromUnit<N, AttoSecond> for AttoSecond

type Output = N

pub fn from_unit(num: N) -> <AttoSecond as FromUnit<N, AttoSecond>>::Output

impl<N> FromUnit<N, CentiSecond> for CentiSecond

type Output = N

pub fn from_unit(num: N) -> <CentiSecond as FromUnit<N, CentiSecond>>::Output

impl<N> FromUnit<N, DeciSecond> for DeciSecond

type Output = N

pub fn from_unit(num: N) -> <DeciSecond as FromUnit<N, DeciSecond>>::Output

impl<N> FromUnit<N, DekaSecond> for DekaSecond

type Output = N

pub fn from_unit(num: N) -> <DekaSecond as FromUnit<N, DekaSecond>>::Output

impl<N> FromUnit<N, ExaSecond> for ExaSecond

type Output = N

pub fn from_unit(num: N) -> <ExaSecond as FromUnit<N, ExaSecond>>::Output

impl<N> FromUnit<N, FemtoSecond> for FemtoSecond

type Output = N

pub fn from_unit(num: N) -> <FemtoSecond as FromUnit<N, FemtoSecond>>::Output

impl<N> FromUnit<N, GigaSecond> for GigaSecond

type Output = N

pub fn from_unit(num: N) -> <GigaSecond as FromUnit<N, GigaSecond>>::Output

impl<N> FromUnit<N, HectoSecond> for HectoSecond

type Output = N

pub fn from_unit(num: N) -> <HectoSecond as FromUnit<N, HectoSecond>>::Output

impl<N> FromUnit<N, KiloSecond> for KiloSecond

type Output = N

pub fn from_unit(num: N) -> <KiloSecond as FromUnit<N, KiloSecond>>::Output

impl<N> FromUnit<N, MegaSecond> for MegaSecond

type Output = N

pub fn from_unit(num: N) -> <MegaSecond as FromUnit<N, MegaSecond>>::Output

impl<N> FromUnit<N, MicroSecond> for MicroSecond

type Output = N

pub fn from_unit(num: N) -> <MicroSecond as FromUnit<N, MicroSecond>>::Output

impl<N> FromUnit<N, MilliSecond> for MilliSecond

type Output = N

pub fn from_unit(num: N) -> <MilliSecond as FromUnit<N, MilliSecond>>::Output

impl<N> FromUnit<N, NanoSecond> for NanoSecond

type Output = N

pub fn from_unit(num: N) -> <NanoSecond as FromUnit<N, NanoSecond>>::Output

impl<N> FromUnit<N, PetaSecond> for PetaSecond

type Output = N

pub fn from_unit(num: N) -> <PetaSecond as FromUnit<N, PetaSecond>>::Output

impl<N> FromUnit<N, PicoSecond> for PicoSecond

type Output = N

pub fn from_unit(num: N) -> <PicoSecond as FromUnit<N, PicoSecond>>::Output

impl<N> FromUnit<N, Second> for Second

type Output = N

pub fn from_unit(num: N) -> <Second as FromUnit<N, Second>>::Output

impl<N> FromUnit<N, TeraSecond> for TeraSecond

type Output = N

pub fn from_unit(num: N) -> <TeraSecond as FromUnit<N, TeraSecond>>::Output

impl<N> FromUnit<N, YoctoSecond> for YoctoSecond

type Output = N

pub fn from_unit(num: N) -> <YoctoSecond as FromUnit<N, YoctoSecond>>::Output

impl<N> FromUnit<N, YottaSecond> for YottaSecond

type Output = N

pub fn from_unit(num: N) -> <YottaSecond as FromUnit<N, YottaSecond>>::Output

impl<N> FromUnit<N, ZeptoSecond> for ZeptoSecond

type Output = N

pub fn from_unit(num: N) -> <ZeptoSecond as FromUnit<N, ZeptoSecond>>::Output

impl<N> FromUnit<N, ZettaSecond> for ZettaSecond

type Output = N

pub fn from_unit(num: N) -> <ZettaSecond as FromUnit<N, ZettaSecond>>::Output

impl<N> FromUnit<N, MetreParMetre> for MetreParMetre

type Output = N

pub fn from_unit(
    num: N
) -> <MetreParMetre as FromUnit<N, MetreParMetre>>::Output

impl<N> FromUnit<N, ParSecond> for ParSecond

type Output = N

pub fn from_unit(num: N) -> <ParSecond as FromUnit<N, ParSecond>>::Output