CODEWITHSUNDEEP
rust
KasMA1990
KasMA1990

Reputation: 153

Require trait implementations to be convertible between each other

I'm trying to have a Rust trait X which requires that anyone implementing X can convert to other implementations of X.

So I'm trying to make the declaration of X enforce this like so:

trait X<T> : From<T> where T: X {}

But the compiler is telling me that it doesn't find any type arguments in my specification of T, because T: X needs some type information T: X<...>. But this way there will always be one type argument too little; e.g.

trait X<T, U> : From<T> where T: X<U> {}

Can I get around this in some way? Doing where T: X<_> is not allowed.

Upvotes: 1

Views: 186

Answers (1)

Chris Emerson
Chris Emerson

Reputation: 14021

Rather than trying to restrict the implementers, I think it would be simpler to provide the implementation as part of the trait:

trait Length {
    fn unit_in_meters() -> f64;

    fn value(&self) -> f64;
    fn new(value: f64) -> Self;

    fn convert_to<T:Length>(&self) -> T {
        T::new(self.value() * Self::unit_in_meters() / T::unit_in_meters())
    }
}

struct Mm {
    v: f64,
}

impl Length for Mm {
    fn unit_in_meters() -> f64 { 0.001 }

    fn value(&self) -> f64 { self.v }
    fn new(value: f64) -> Mm {
        Mm{ v: value }
    }
}

struct Inch {
    v: f64,
}

impl Length for Inch {
    fn unit_in_meters() -> f64 { 0.0254 }

    fn value(&self) -> f64 { self.v }
    fn new(value: f64) -> Inch {
        Inch{ v: value }
    }
}

fn main() {
    let foot = Inch::new(12f64);
    let foot_in_mm: Mm = foot.convert_to();
    println!("One foot in mm: {}", foot_in_mm.value());
}

Play link

For fun, with the associated_consts feature you can swap the method for a constant conversion factor.

#![feature(associated_consts)]
trait Length {
    const UNIT_IN_METERS: f64;

    fn value(&self) -> f64;
    fn new(value: f64) -> Self;

    fn convert_to<T:Length>(&self) -> T {
        T::new(self.value() * Self::UNIT_IN_METERS / T::UNIT_IN_METERS)
    }
}

struct Mm {
    v: f64,
}

impl Length for Mm {
    const UNIT_IN_METERS: f64 = 0.001;

    fn value(&self) -> f64 { self.v }
    fn new(value: f64) -> Mm {
        Mm{ v: value }
    }
}

struct Inch {
    v: f64,
}

impl Length for Inch {
    const UNIT_IN_METERS: f64 = 0.0254;

    fn value(&self) -> f64 { self.v }
    fn new(value: f64) -> Inch {
        Inch{ v: value }
    }
}

fn main() {
    let foot = Inch::new(12f64);
    let foot_in_mm: Mm = foot.convert_to();
    println!("One foot in mm: {}", foot_in_mm.value());
}

Play link

Upvotes: 3

Related Questions