pow inference is not great

[oriongonza]

fn do_pow(n: i32) -> f64 {
    0.95.powi(n)
}

error[E0689]: can't call method `powi` on ambiguous numeric type `{float}`
   --> mail/mail-common/src/mailbox/attachments.rs:335:18
    |
335 |             0.95.powi(n)
    |                  ^^^^
    |
help: you must specify a concrete type for this numeric value, like `f32`
    |
335 |             0.95_f32.powi(n)
    |             ~~~~~~~~

Why can't the compiler infer that if it's being expected to produce a f64 the type should be an f64?
I can't think of any other cases outside of pow where the inference fails.

[meithecatte]

All functions being called on numeric types work like this.

This doesn't happen for operators like + because that goes through the trait resolver, I think.

[compiler-errors]

Why can't the compiler infer that if it's being expected to produce a f64 the type should be an f64?

Because all numeric types define separate pow methods. Method selection cannot know that all pow functions have any underlying pattern to their method signatures, because they're not unified by an underlying trait that gives us a way to reason about these pow methods.

All functions being called on numeric types work like this.

Correct.

This doesn't happen for operators like + because that goes through the trait resolver, I think.

It's not because it goes through the trait solver, but because we special-case operators and inference in typeck.

[oriongonza]

I guess that for me this only comes up when calling pow 😄

Is this a duplicate issue? If so I can close, if not, I can make a more general issue and close this too.