Implemented Mul operator trait can't be used

[bluss]

A user provided the following test case that fails compiling at the point where the * operator is used.

use std::ops::Mul;

#[derive(Copy)]
pub struct S {
    a: f64
}

impl Mul<f64> for S {
    type Output = S;

    fn mul(self, scalar: f64) -> S {
        S {
            a: self.a * scalar
        }
    }
}

impl Mul<S> for f64 {
    type Output = S;

    fn mul(self, s: S) -> S {
        s.mul(self)
    }
}

fn main() {
    let s = S {a: 0f64};
    s * 5f64;
    5f64 * s; // error: mismatched types: expected `f64`, found `S`
              // (expected f64, found struct `S`) [E0308]
}

[mdinger]

Maybe a dup of #19035 ? Seems similar.

[bluss]

I'm not sure and here's the reason: in #19035, today's coherence rules don't allow the correct trait impls to define addition/multiplication both ways.

What made me react in this bug was that the trait impls are accepted by the compiler, but the operator still doesn't work.

[Diggsey]

I don't think coherence rules prevent this: there's no way a sibling crate could contain a different implementation of Mul<S> for f64 because it would have to import this crate to learn of S, and in doing so it would learn of this crate's implementation.

It can't implement a generic version, Mul<T> for f64 because that would violate the coherence rules, as T is not constrained by a local type, and f64 isn't a local type either.

[mdinger]

Isn't this a big 1.0 problem? You can do lots of things but not math...