Why does iterating a vector of i32s give references to i32 (&i32)?

Question

The following program tries to grade the marks of a student:

use std::io;

fn main() {
    let mut in0 = String::new();
    io::stdin().read_line(&mut in0).expect("stdin err");
    let n: i32 = in0.trim().parse().expect("parse err");
    println!("{}", n);
    let mut v: Vec<i32> = Vec::new();
    for _ in 0..n {
        let mut inp = String::new();
        io::stdin().read_line(&mut inp).expect("stdin err");
        let num: i32 = inp.trim().parse().unwrap();
        v.push(num);
    }
    let out: Vec<_> = v
        .iter()
        .map(|x| {
            if x < 38 {
                x
            } else if x % 5 > 3 {
                x + x % 5
            } else {
                x
            }
        })
        .collect();
    println!("{:?}", v);
}

While compiling, I get the following error.

error[E0308]: mismatched types
  --> src/main.rs:19:20
   |
19 |             if x < 38 {
   |                    ^^
   |                    |
   |                    expected `&i32`, found integer
   |                    help: consider borrowing here: `&38`

error[E0308]: `if` and `else` have incompatible types
  --> src/main.rs:24:17
   |
21 |               } else if x % 5 > 3 {
   |  ____________________-
22 | |                 x + x % 5
   | |                 --------- expected because of this
23 | |             } else {
24 | |                 x
   | |                 ^ expected `i32`, found `&i32`
25 | |             }
   | |_____________- `if` and `else` have incompatible types
   |
help: consider dereferencing the borrow
   |
23 |             } else *{
24 |                 x
25 |             }

How is the x variable a &i32 type and not a i32 type?

Answer 1

Calling the .iter() method on a vector returns an iterator over references the vector's elements. Otherwise, it would have to move or copy the elements out of the vector, which is not desirable in the general case ^[1]. In the documentation this is not immediately obvious from the declaration:

pub fn iter(&self) -> Iter<T>  // Return type does not look like a reference

However, the examples show that you get a reference:

assert_eq!(iterator.next(), Some(&1));  // note the `&1` instead of just `1`

The closure can be instructed to dereference the parameter:

v.iter().map(|&x| { /* do something */ })

This is fine if the vector contains Copyable types like i32. Otherwise this would result in a cannot move out of borrowed content error. In this case you will likely want to work with a reference anyway.

If you no longer need the vector after iterating you can use .into_iter(), which consumes the vector and iterates over owned items instead of references.

_{[1] Moving would clear the vector, which is covered by the .drain() method, and copying is not possible/efficient on all types.}