Iterator::sum requires type annotations in seemingly simple cases

[glandium]

Even with type annotations, Iterator::sum is not handled very nicely:

    let foo: usize = (1usize..10).sum() + 1usize;

fails to build with:

error[[E0283]](https://doc.rust-lang.org/stable/error-index.html#E0283): type annotations needed
 --> src/main.rs:2:35
  |
2 |     let foo: usize = (1usize..10).sum() + 1usize;
  |                                   ^^^ cannot infer type of the type parameter `S` declared on the associated function `sum`
  |
  = note: cannot satisfy `_: Sum<usize>`
note: required by a bound in `std::iter::Iterator::sum`
help: consider specifying the generic argument
  |
2 |     let foo: usize = (1usize..10).sum::<S>() + 1usize;
  |                                      +++++
help: consider specifying the type argument in the function call
  |
2 |     let foo: usize = (1usize..10).sum::<S>() + 1usize;
  |                                      +++++

The converse:

    let bar: usize = 1usize + (1usize..10).sum();

fails to build with:

error[[E0284]](https://doc.rust-lang.org/stable/error-index.html#E0284): type annotations needed: cannot satisfy `<usize as Add<_>>::Output == usize`
 --> src/main.rs:2:29
  |
2 |     let bar: usize = 1usize + (1usize..10).sum();
  |                             ^ cannot satisfy `<usize as Add<_>>::Output == usize`

[GKFX]

That is as expected. More than one type might have Sum<usize> implemented for it. E.g.

use core::iter::Sum;

struct A;
struct B;
#[derive(Clone, Copy)]
struct C;

impl<'a> Sum<&'a C> for A {
    fn sum<I>(_: I) -> Self where I: Iterator<Item = &'a C> {
        A
    }
}

impl<'a> Sum<&'a C> for B {
    fn sum<I>(_: I) -> Self where I: Iterator<Item = &'a C> {
        B
    }
}

fn main() {
    let c = [C; 5];
    let _a: A = c.iter().sum();
    let _b: B = c.iter().sum();
}

Adding 1usize doesn't disambiguate anything because it might be possible for more than one type to have Add<usize> implemented too,

You can get all the types inferred with a single type annotation:

let foo = (1..10).sum::<usize>() + 1;

[frewsxcv]

More than one type might have Sum implemented for it.

How difficult would it be to add wording like this to the diagnostics?

[vincenzopalazzo]

How difficult would it be to add wording like this to the diagnostics?

cc @compiler-errors

[ifsheldon]

I encountered this as well. Although I knew how to fix the error, the diagonostics is partially wrong IMO.

My code is

let v = vec![1, 2];
let sum = v
    .iter()
    .map(|val| *val )
    .sum();
let bool = sum > 0;
assert_eq!(bool, true);

The diagonostics was:

error[E0283]: type annotations needed
    --> src/main.rs:178:13
     |
178  |         let sum = v
     |             ^^^
...
181  |             .sum();
     |              --- type must be known at this point
     |
     = note: cannot satisfy `_: Sum<i32>`
     = help: the following types implement trait `Sum<A>`:
               `Duration` implements `Sum<&'a Duration>`
               `Duration` implements `Sum`
               `Option<T>` implements `Sum<Option<U>>`
               `Result<T, E>` implements `Sum<Result<U, E>>`
               `Simd<f32, N>` implements `Sum<&'a Simd<f32, N>>`
               `Simd<f32, N>` implements `Sum`
               `Simd<f64, N>` implements `Sum<&'a Simd<f64, N>>`
               `Simd<f64, N>` implements `Sum`
             and 72 others
note: required by a bound in `std::iter::Iterator::sum`
    --> /Users/zhiqiu/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:3575:12
     |
3572 |     fn sum<S>(self) -> S
     |        --- required by a bound in this associated function
...
3575 |         S: Sum<Self::Item>,
     |            ^^^^^^^^^^^^^^^ required by this bound in `Iterator::sum`
help: consider giving `sum` an explicit type
     |
178  |         let sum: /* Type */ = v
     |                ++++++++++++

For more information about this error, try `rustc --explain E0283`.

The first help message "the following types implement trait ..." is wrong for being not helpful IMO, while the second can helpfully address the problem.