Left multiplication for vector spaces

[milibopp]

This code example fails:

fn foo<V: VectorSpace<Field=f64>>(a: V, b: V, c: f64) -> V {
    a * c + c * b
}

with this error:

error[E0277]: the trait bound `f64: std::ops::Mul<V>` is not satisfied
   |
   |     a * c + c * b
   |               ^ no implementation for `f64 * V`
   |
   = help: the trait `std::ops::Mul<V>` is not implemented for `f64`
   = help: consider adding a `where f64: std::ops::Mul<V>` bound

(omitted source location in my project for clarity)

Is there a reason, why this can't be made work? As multiplication on the field commutes anyway, the operator should generally be available in this way.

[WaDelma]

I was going to say how orphan rules makes it impossible, but then I realised you can actually require the Mul implementation.

Not sure if it generalises to the actual VectorSpace trait, but it seems to be doable.

[milibopp]

Looks like that is not enough for the example above. The compiler does not interpret the where clause as an implication, forcing you to explicitly add it again.

To reduce it a bit further, this does not work. I have a hunch that fixing it would be a huge problem for the type system or something.

[milibopp]

nice ppl on IRC pointed me to these issues:

• where clauses are only elaborated for supertraits, and not other things rust-lang/rust#20671
• Implied bounds rust-lang/rfcs#2089

[milibopp]

I would argue that before this implication works, it is hardly useful to users to change this. Type authors would have to provide the implementation on the ring or field right away and everybody would have to write down the trait bound no matter whether it is used or not.

So perhaps this should be deferred to a time, when implied bounds stabilize.