Binop type mismatch error could be better

[brson]

From the new book.

let x: i8 = 5;
let y: Option<i8> = Some(5);

let sum = x + y;

If we run this code, we get an error message like this:

error[E0277]: the trait bound `i8: std::ops::Add<std::option::Option<i8>>` is not satisfied
 -->
  |
7 | let sum = x + y;
  |           ^^^^^
  |

This error could be a lot more newbie friendly. The next section of the book even has to apologize and explain:

"Intense! What this error message is trying to say is that Rust does not understand how to add an Option and an i8, since they're different types."

cc @jonathandturner @rust-lang/docs

[brson]

On the other hand, one might argue that it's important for users to understand how to interpret this error. It seems like binops though could be special case to say "The operator + is not implemented for ...".

[sanmai-NL]

I also think unimplemented operators in general could be described more accessibly in the way you described @brson.

The error message you gave as an example would be optimal, I think, if it pointed out instead that it pertains to x, even though the whole context is x + y. I expect that a novice programmer will then understand the problem more readily.

[clarfonthey]

I think that the general gist of the error is good, but it should add something mentioning that the reason why it needs this trait is because the function add is not implemented.

Perhaps we could explain this using the regular trait-not-found error and do something like:

"The compiler converts this operation into the form x.add(y), using the Add trait. Because this trait isn't implemented, the operation could not be performed."

That way, it tells users 1) what the compiler actually is doing with the operation and 2) doesn't add any special case for this error, just adds on information in addition to the trait error to help the user understand the conversion.

[killercup]

I think as a first step it would be helpful to add type annotations to x and y. For example:

error[E0277]: the trait bound `i8: std::ops::Add<std::option::Option<i8>>` is not satisfied
 -->
  |
7 | let sum = x + y;
  |           ^   - `std::option::Option<i8>`
  |           |   
  |          `i8`

This way, people can at least recognize the Option<i8> in the error message as the type of y. I think this might be helpful in other "trait bound not satisfied" cases as well.

For operators in particular, it might be nice to add a sentence saying + becomes std::ops::Add::add. Alternatively, add an annotation to the +, but I think this will make it very noisy.

[oli-obk]

This has now a

note: no implementation for i8 + std::option::Option<i8>