Why does the compiler not complain that an iterator moved to a for loop is immutable?

by

The book says the for loop took ownership of v1_iter and made it mutable behind the scenes,

Exactly, and one can make an even simpler example:

let v = vec![1,2,3];
let mut x = v;
x.push(0);

Note that v and x are separate variable bindings: for as long as the variable v retained our 3-element vector, the contract of the variable was that the vector will not be mutated. However, the vector was moved to x, which declares that mutability is acceptable. The same applies to function calls:

fn foo(mut x: Vec<i32>) {
    x.push(0);
}

let v = vec![1,2,3];
foo(v);

This is safe because only one of the variables owns the vector at any point of its lifetime. Once v was moved to x, v can no longer be used. Likewise, in your code, v1_iter can no longer be used after the for loop.

but can you convert an immutable variable to mutable?

Both snippets work because the value was moved to a new variable declared as mut. However, once a variable is declared as immutable (or mutable), that variable stays so for all of its lifetime, and that cannot be changed. So the answer is no, but ownership semantics enable moving values across variables with different mutability guarantees.

See also:

More Related Contents:

  1. What are move semantics in Rust?
  2. How does Rust provide move semantics?
  3. Why is the mutable reference not moved here?
  4. Can Rust optimise away the bit-wise copy during move of an object someday?
  5. Why can’t I store a value and a reference to that value in the same struct?
  6. How do I create a heterogeneous collection of objects?
  7. How do I stop iteration and return an error when Iterator::map returns a Result::Err?
  8. Are polymorphic variables allowed?
  9. Why does Iterator::take_while take ownership of the iterator?
  10. Efficiently mutate a vector while also iterating over the same vector
  11. Why do I need rebinding/shadowing when I can have mutable variable binding?
  12. How do I use the Entry API with an expensive key that is only constructed if the Entry is Vacant?
  13. How do I split a string in Rust?
  14. How can I put an async function into a map in Rust?
  15. Is it possible to implement methods on type aliases?
  16. How do I synchronously return a value calculated in an asynchronous Future?
  17. How do I move out of a struct field that is an Option?
  18. Removing elements from a Vec based on some condition [duplicate]
  19. How can I change enum variant while moving the field to the new variant?
  20. What is unwrap in Rust, and what is it used for?
  21. What’s the difference between using the return statement and omitting the semicolon in Rust?
  22. The trait `FnMut` is not implemented for `String` when trying to split a string
  23. HashMap borrow issue when trying to implement find or insert
  24. Why “explicit lifetime bound required” for Box in struct?
  25. What is the difference between `|_| async move {}` and `async move |_| {}`
  26. Cannot use moved BufReader after for loop with bufreader.lines()
  27. How to repeat a static string at compile time
  28. Is there a good way to convert a Vec to an array?
  29. How to concatenate static strings in Rust
  30. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?

Leave a Comment