Problem implementing a trait to multiple types

Question

As a practice exercise, I'm trying to create a temperature unit library.

Currently, the following code won't compile and the error message is unclear to me. The problem seems to be a type conflict.

type Fahrenheit = f64;
type Celcius = f64;
type Kelvin = f64;


trait TemperatureUnit {
    fn to_kelvin(&self) -> Kelvin;
}

impl TemperatureUnit for Fahrenheit {
    fn to_kelvin(&self) -> Kelvin {
        (*self + 459.67) * 5/9
    }
}

impl TemperatureUnit for Celcius {
    fn to_kelvin(&self) -> Kelvin {
        *self + 273.15
    } 
}

impl TemperatureUnit for Kelvin {
    fn to_kelvin(&self) -> Kelvin {
        *self
    }
}

Errors:

error[E0119]: conflicting implementations of trait `TemperatureUnit` for type `f64`
  --> src/lib.rs:18:1
   |
12 | impl TemperatureUnit for Fahrenheit {
   | ----------------------------------- first implementation here
...
18 | impl TemperatureUnit for Celcius {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `f64`

error[E0119]: conflicting implementations of trait `TemperatureUnit` for type `f64`
  --> src/lib.rs:24:1
   |
12 | impl TemperatureUnit for Fahrenheit {
   | ----------------------------------- first implementation here
...
24 | impl TemperatureUnit for Kelvin {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `f64`

Playground

I'm new to Rust, so maybe this is not the proper methodology to achieve a compiler-enforced type-safe unit conversion.

Silvio Mayolo · Accepted Answer · 2022-06-17 13:37:16Z

6

When you write type, you're making a type alias, not a new type. It's like when you use typedef in C++, for instance.

type Fahrenheit = f64;

This literally says "when I say 'Fahrenheit', pretend I said f64 instead". Not a new type, not a distinct structure, literally the same. So you just implemented TemperatureUnit for f64 three times.

If you want to wrap f64 in a custom type under your control, you're looking for the newtype pattern.

pub struct Fahrenheit(pub f64);

Now Fahrenheit is a distinct structure that happens to be isomorphic to f64. You can go from f64 to Fahrenheit with the Fahrenheit(x) constructor, and you can go back with the my_fahrenheit.0 projection. You can also name the projection if you prefer.

pub struct Fahrenheit { pub float_repr: f64 };

Rust will almost certainly compile this internally to an actual f64. Structs with only one field will generally have no overhead. But we can actually guarantee this with repr(transparent)

#[repr(transparent)]
pub struct Fahrenheit(pub f64);

This guarantees that, at runtime, Fahrenheit and f64 have the same representation (even to the extent that transmute is defined between them), while at compile-time they're distinct types.

The only thing left to decide is what traits you want your new type to implement. It will inherit nothing from f64 by default, so you'll likely have a massive derive(...) clause right before the declaration including Eq, Ord, Clone, Copy, etc. (non-exhaustive list; you know your use case better than I do)

answered Jun 17, 2022 at 13:37

Silvio Mayolo

70.9k6 gold badges91 silver badges139 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Chayim Friedman Over a year ago

Do not use #[repr(transparent)] unless you need it for unsafe code: AFAIK it is actually the same today, and when not I'd expect the default representation to be more performant.

gberth Over a year ago

Thank you for your time. Your answer was clear and complete. Not sure about the implication of isomorphic in a CS context (transmute == inverse mapping ? ).

Silvio Mayolo Over a year ago

@gberth Sorry, category theory brain getting ahead of me. Don't read too much into that. I just mean that the two store the same data. There's a map Fahrenheit -> f64 and one f64 -> Fahrenheit that are inverses of each other.

gberth Over a year ago

Thanks for your answer. The rust vocabulary is quite extensive, so I was wondering if I was missing something. :^)

Jon · Accepted Answer · 2022-06-17 13:40:50Z

The problem here is that type just aliases a type, it doesn't create a new one. Rust is complaining because those three impl blocks are trying to implement TemperatureUnit on the same type three times.

Instead, you should declare new types. The example below uses struct.

Rust playground

struct Fahrenheit(f64);
struct Celcius(f64);
struct Kelvin(f64);


trait TemperatureUnit {
    fn to_kelvin(&self) -> Kelvin;
}

impl TemperatureUnit for Fahrenheit {
    fn to_kelvin(&self) -> Kelvin {
        Kelvin((self.0 + 459.67) * 5.0/9.0)
    }
}

impl TemperatureUnit for Celcius {
    fn to_kelvin(&self) -> Kelvin {
        Kelvin(self.0 + 273.15)
    } 
}

impl TemperatureUnit for Kelvin {
    fn to_kelvin(&self) -> Kelvin {
        Kelvin(self.0)
    }
}


fn main()
{
    println!("Hey");
}

Collectives™ on Stack Overflow

Problem implementing a trait to multiple types

2 Answers 2

4 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related