Access value after it has been borrowed

Question

I have the following function. It is given a file. It should return a random line from the file as a string.

fn get_word(word_list: File) -> String {
    let reader = BufReader::new(word_list);

    let lines = reader.lines();
    let word_count = lines.count();

    let y: usize = thread_rng().gen_range(0, word_count - 1);
    

    let element = lines.nth(y);
    match element {

        Some(x) => println!("Result: {}", x.unwrap()),

        None => println!("Error with nth"),
    }

    let word = String::new(""); // Once the error is gone. I would create the string.
    return word;
}

But I keep getting this error:

93  |     let lines = reader.lines();
    |         ----- move occurs because `lines` has type `std::io::Lines<BufReader<File>>`, which does not implement the `Copy` trait
94  |     let word_count = lines.count();
    |                            ------- `lines` moved due to this method call
...
99  |     let element = lines.nth(y);
    |                   ^^^^^^^^^^^^ value borrowed here after move
    |

I am new to Rust and have been learning by try and error. I don't know how to access the data after I have called the count function. If there is another method to accomplish what I want, I would gladly welcome it.

Answer 1

The .count() method consumes the iterator. From the documentation

Consumes the iterator, counting the number of iterations and returning it. This method will call next repeatedly until None is encountered, returning the number of times it saw Some. Note that next has to be called at least once even if the iterator does not have any elements.

In other words, it reads the file content and discards it. If you want to get the Nth line, then you have to re-read the file using another iterator instance.

If your file is small, you can save the read lines in a vector:

let lines = reader.lines().collect::<Vec<String>>();

Then the length of the vector is the number of lines and you can avoid re-reading the file, but if it's a large file you may end-up crashing with "out of memory" error. In that case you should re-read the file content, or use a better strategy such as indexing where the new lines are, so you can jump straight to the new line, without having to re-read a lot of data.

Answer 2

The value returned by lines is an iterator, which reads the file sequentially. To count the number of lines, the iterator is consumed: self is taken by value; ownership is transferred into the count() function. So you can't rewind and then request the nth line.

The easiest solution is to read all the lines into a vector:

    let lines = reader.lines().collect::<Vec<String>>();
    let word_count = lines.len();

    let y: usize = thread_rng().gen_range(0, word_count - 1);

    let word = lines[y].clone();
    return word;

Notice the clone call: you can't simply write return lines[y]; because you'd be borrowing the string from the vector, but the vector is destroyed as soon as the function returns. By returning a clone of the string, this is avoided.

(to_owned or even to_string would also work. You can also avoid a copy by using swap_remove; I'm not sure there is a more elegant way to move one element from a vector and discard the rest.)

Answer 3

Note that counting the lines and then selecting one of them requires you to either rewind the iterator and go through it twice (once to count and once to select), or to store everything in memory first (e.g. with .collect::<Vec<_>>). Selecting a random line from the list can however be done in a single pass by randomly choosing on each line whether to keep the currently selected line or replacing it with the latest read line:

fn get_word(word_list: File) -> String {
    let reader = BufReader::new(word_list);

    let lines = reader.lines();

    let mut selected = lines.next().unwrap();
    let mut count = 0;
    for l in lines {
        count += 1;
        if thread_rng().gen_range (0, count) == 0 {
            selected = l;
        }
    }

    match selected {
        Ok(x) => return x,
        Err(_) => {
            print!("Error get_word");
            return String::new();
        }
    }
}

Or of course the simplest way is to just use choose:

fn get_word(word_list: File) -> String {
    use rand::seq::IteratorRandom;

    let reader = BufReader::new(word_list);
    match reader.lines.choose (thread_rng()) {
        Some (Ok (x)) => return x,
        _ => {
            print!("Error get_word");
            return String::new();
        }
    }
}