error[E0277]: a value of type `Vec<X>` cannot be built from an iterator over elements of type `&X`
  --> $DIR/invalid-iterator-chain.rs:6:7
   |
LL |     let i = i.map(|x| x.clone());
   |                         ------- this method call is cloning the reference `&X`, not `X` which doesn't implement `Clone`
LL |     i.collect()
   |       ^^^^^^^ value of type `Vec<X>` cannot be built from `std::iter::Iterator<Item=&X>`
   |
   = help: the trait `FromIterator<&X>` is not implemented for `Vec<X>`
   = help: the trait `FromIterator<X>` is implemented for `Vec<X>`
   = help: for that trait implementation, expected `X`, found `&X`
note: the method call chain might not have had the expected associated types
  --> $DIR/invalid-iterator-chain.rs:4:26
   |
LL | fn iter_to_vec<'b, X>(i: Iter<'b, X>) -> Vec<X> {
   |                          ^^^^^^^^^^^ `Iterator::Item` is `&X` here
LL |     let i = i.map(|x| x.clone());
   |               ------------------ `Iterator::Item` remains `&X` here
note: required by a bound in `collect`
  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
help: consider further restricting type parameter `X`
   |
LL | fn iter_to_vec<'b, X>(i: Iter<'b, X>) -> Vec<X> where X: Clone {
   |                                                 ++++++++++++++

error[E0277]: a value of type `i32` cannot be made by summing an iterator over elements of type `()`
  --> $DIR/invalid-iterator-chain.rs:15:33
   |
LL |     println!("{}", scores.sum::<i32>());
   |                           ---   ^^^ value of type `i32` cannot be made by summing a `std::iter::Iterator<Item=()>`
   |                           |
   |                           required by a bound introduced by this call
   |
   = help: the trait `Sum<()>` is not implemented for `i32`
   = help: the following other types implement trait `Sum<A>`:
             <i32 as Sum>
             <i32 as Sum<&'a i32>>
note: the method call chain might not have had the expected associated types
  --> $DIR/invalid-iterator-chain.rs:12:10
   |
LL |       let scores = vec![(0, 0)]
   |                    ------------ this expression has type `Vec<({integer}, {integer})>`
LL |           .iter()
   |            ------ `Iterator::Item` is `&({integer}, {integer})` here
LL |           .map(|(a, b)| {
   |  __________^
LL | |             a + b;
LL | |         });
   | |__________^ `Iterator::Item` changed to `()` here
note: required by a bound in `std::iter::Iterator::sum`
  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
help: consider removing this semicolon
   |
LL -             a + b;
LL +             a + b
   |

error[E0277]: a value of type `i32` cannot be made by summing an iterator over elements of type `()`
  --> $DIR/invalid-iterator-chain.rs:26:20
   |
LL |             .sum::<i32>(),
   |              ---   ^^^ value of type `i32` cannot be made by summing a `std::iter::Iterator<Item=()>`
   |              |
   |              required by a bound introduced by this call
   |
   = help: the trait `Sum<()>` is not implemented for `i32`
   = help: the following other types implement trait `Sum<A>`:
             <i32 as Sum>
             <i32 as Sum<&'a i32>>
note: the method call chain might not have had the expected associated types
  --> $DIR/invalid-iterator-chain.rs:25:14
   |
LL |         vec![0, 1]
   |         ---------- this expression has type `Vec<{integer}>`
LL |             .iter()
   |              ------ `Iterator::Item` is `&{integer}` here
LL |             .map(|x| x * 2)
   |              -------------- `Iterator::Item` changed to `{integer}` here
LL |             .map(|x| x as f64)
   |              ----------------- `Iterator::Item` changed to `f64` here
LL |             .map(|x| x as i64)
   |              ----------------- `Iterator::Item` changed to `i64` here
LL |             .filter(|x| *x > 0)
   |              ------------------ `Iterator::Item` remains `i64` here
LL |             .map(|x| { x + 1 })
   |              ------------------ `Iterator::Item` remains `i64` here
LL |             .map(|x| { x; })
   |              ^^^^^^^^^^^^^^^ `Iterator::Item` changed to `()` here
note: required by a bound in `std::iter::Iterator::sum`
  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
help: consider removing this semicolon
   |
LL -             .map(|x| { x; })
LL +             .map(|x| { x })
   |

error[E0277]: a value of type `i32` cannot be made by summing an iterator over elements of type `f64`
  --> $DIR/invalid-iterator-chain.rs:36:20
   |
LL |             .sum::<i32>(),
   |              ---   ^^^ value of type `i32` cannot be made by summing a `std::iter::Iterator<Item=f64>`
   |              |
   |              required by a bound introduced by this call
   |
   = help: the trait `Sum<f64>` is not implemented for `i32`
   = help: the following other types implement trait `Sum<A>`:
             <i32 as Sum>
             <i32 as Sum<&'a i32>>
note: the method call chain might not have had the expected associated types
  --> $DIR/invalid-iterator-chain.rs:33:14
   |
LL |         vec![0, 1]
   |         ---------- this expression has type `Vec<{integer}>`
LL |             .iter()
   |              ------ `Iterator::Item` is `&{integer}` here
LL |             .map(|x| x * 2)
   |              -------------- `Iterator::Item` changed to `{integer}` here
LL |             .map(|x| x as f64)
   |              ^^^^^^^^^^^^^^^^^ `Iterator::Item` changed to `f64` here
LL |             .filter(|x| *x > 0.0)
   |              -------------------- `Iterator::Item` remains `f64` here
LL |             .map(|x| { x + 1.0 })
   |              -------------------- `Iterator::Item` remains `f64` here
note: required by a bound in `std::iter::Iterator::sum`
  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL

error[E0277]: a value of type `i32` cannot be made by summing an iterator over elements of type `()`
  --> $DIR/invalid-iterator-chain.rs:38:60
   |
LL |     println!("{}", vec![0, 1].iter().map(|x| { x; }).sum::<i32>());
   |                                                      ---   ^^^ value of type `i32` cannot be made by summing a `std::iter::Iterator<Item=()>`
   |                                                      |
   |                                                      required by a bound introduced by this call
   |
   = help: the trait `Sum<()>` is not implemented for `i32`
   = help: the following other types implement trait `Sum<A>`:
             <i32 as Sum>
             <i32 as Sum<&'a i32>>
note: the method call chain might not have had the expected associated types
  --> $DIR/invalid-iterator-chain.rs:38:38
   |
LL |     println!("{}", vec![0, 1].iter().map(|x| { x; }).sum::<i32>());
   |                    ---------- ------ ^^^^^^^^^^^^^^^ `Iterator::Item` changed to `()` here
   |                    |          |
   |                    |          `Iterator::Item` is `&{integer}` here
   |                    this expression has type `Vec<{integer}>`
note: required by a bound in `std::iter::Iterator::sum`
  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
help: consider removing this semicolon
   |
LL -     println!("{}", vec![0, 1].iter().map(|x| { x; }).sum::<i32>());
LL +     println!("{}", vec![0, 1].iter().map(|x| { x }).sum::<i32>());
   |

error[E0277]: a value of type `i32` cannot be made by summing an iterator over elements of type `&()`
  --> $DIR/invalid-iterator-chain.rs:39:46
   |
LL |     println!("{}", vec![(), ()].iter().sum::<i32>());
   |                                        ---   ^^^ value of type `i32` cannot be made by summing a `std::iter::Iterator<Item=&()>`
   |                                        |
   |                                        required by a bound introduced by this call
   |
   = help: the trait `Sum<&()>` is not implemented for `i32`
   = help: the following other types implement trait `Sum<A>`:
             <i32 as Sum>
             <i32 as Sum<&'a i32>>
note: the method call chain might not have had the expected associated types
  --> $DIR/invalid-iterator-chain.rs:39:33
   |
LL |     println!("{}", vec![(), ()].iter().sum::<i32>());
   |                    ------------ ^^^^^^ `Iterator::Item` is `&()` here
   |                    |
   |                    this expression has type `Vec<()>`
note: required by a bound in `std::iter::Iterator::sum`
  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL

error[E0277]: a value of type `Vec<i32>` cannot be built from an iterator over elements of type `()`
  --> $DIR/invalid-iterator-chain.rs:48:25
   |
LL |     let g: Vec<i32> = f.collect();
   |                         ^^^^^^^ value of type `Vec<i32>` cannot be built from `std::iter::Iterator<Item=()>`
   |
   = help: the trait `FromIterator<()>` is not implemented for `Vec<i32>`
   = help: the trait `FromIterator<i32>` is implemented for `Vec<i32>`
   = help: for that trait implementation, expected `i32`, found `()`
note: the method call chain might not have had the expected associated types
  --> $DIR/invalid-iterator-chain.rs:44:15
   |
LL |       let a = vec![0];
   |               ------- this expression has type `Vec<{integer}>`
LL |       let b = a.into_iter();
   |                 ----------- `Iterator::Item` is `{integer}` here
LL |       let c = b.map(|x| x + 1);
   |                 -------------- `Iterator::Item` remains `{integer}` here
LL |       let d = c.filter(|x| *x > 10 );
   |                 -------------------- `Iterator::Item` remains `{integer}` here
LL |       let e = d.map(|x| {
   |  _______________^
LL | |         x + 1;
LL | |     });
   | |______^ `Iterator::Item` changed to `()` here
LL |       let f = e.filter(|_| false);
   |                 ----------------- `Iterator::Item` remains `()` here
note: required by a bound in `collect`
  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
help: consider removing this semicolon
   |
LL -         x + 1;
LL +         x + 1
   |

error: aborting due to 7 previous errors

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