Why do I get "conflicting implementations of trait" for f32 which does not implement Ord?

Question

I want a min() method for f32, u32 and i32, so I created a trait Min:

trait Min {
    fn min(v1: Self, v2: Self) -> Self;
}

impl<T> Min for T where T: Ord {
    fn min(v1: Self, v2: Self) -> Self {
        ::std::cmp::min(v1, v2)
    }
}

impl Min for f32 {
    fn min(v1: Self, v2: Self) -> Self {
        v1.min(v2)
    }
}

I get an error:

error[E0119]: conflicting implementations of trait `Min` for type `f32`:
  --> src/main.rs:11:1
   |
5  | / impl<T> Min for T where T: Ord {
6  | |     fn min(v1: Self, v2: Self) -> Self {
7  | |         ::std::cmp::min(v1, v2)
8  | |     }
9  | | }
   | |_- first implementation here
10 | 
11 | / impl Min for f32 {
12 | |     fn min(v1: Self, v2: Self) -> Self {
13 | |         v1.min(v2)
14 | |     }
15 | | }
   | |_^ conflicting implementation for `f32`

According to the Rust standard library documentation, f32 does not implement Ord. Why there are conflicting implementations?

Answer 1

I believe this is because the compiler can't rule out the possibility that someday, someone will implement Ord for f32. To put it another way: if the compiler didn't act conservatively, it would be a breaking change to ever implement any new trait on existing types. That would severely limit every library's ability to grow without breaking all downstream users.

There is no direct way around this, as it is an intentional design choice for the language. The closest would be to implement a wrapper type around f32 (i.e. struct OrdF32(f32);) and implement Ord or Min on that, or to use a crate that defines such a wrapper (such as ordered-float).