What are the options to end a mutable borrow in Rust?

by

There is no other way; using blocks is the way to do it. Before Rust 2018 (available in Rust 1.31) all borrows are lexical, that is, they always correspond to some lexical scope. The only scope which is larger than a single statement is that of a block, so blocks are your only tool to limit borrow scopes.

drop() would not work for two reasons: first, because it would require non-lexical scope which is not supported before Rust 2018, and second, it cannot be a general-purpose tool for managing borrows: for example, it wouldn’t be able to end an immutable borrow simply because immutable references are Copy and can’t be “dropped”.

See also:

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. Cannot move out of value which is behind a shared reference when unwrapping
  3. Why does refactoring by extracting a method trigger a borrow checker error?
  4. Temporarily move out of borrowed content
  5. Returning a reference from a HashMap or Vec causes a borrow to last beyond the scope it’s in?
  6. Passing mutable self reference to method of owned object
  7. Mutably borrow one struct field while borrowing another in a closure
  8. Do mutable references have move semantics?
  9. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  10. Double mutable borrow error in a loop happens even with NLL on
  11. How to update-or-insert on a Vec?
  12. “borrowed value does not live long enough” when using the builder pattern
  13. How to use struct self in member method closure
  14. Can’t borrow mutably within two different closures in the same scope
  15. Temporary value is freed at the end of this statement [duplicate]
  16. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  17. How can I modify self in a closure called from a member function?
  18. How do I move out of a struct field that is an Option?
  19. Why does this mutable borrow live beyond its scope?
  20. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  21. How can I create my own data structure with an iterator that returns mutable references?
  22. How can I store a Chars iterator in the same struct as the String it is iterating on?
  23. How to disable unused code warnings in Rust?
  24. Why is the `Sized` bound necessary in this trait?
  25. How do I overcome match arms with incompatible types for structs implementing same trait?
  26. Example of how to use Conditional Compilation Macros in Rust
  27. Why would I use divergent functions?
  28. How to generate statically linked executables?
  29. When is it necessary to circumvent Rust’s borrow checker?
  30. How do I avoid unwrap when converting a vector of Options or Results to only the successful values?

Leave a Comment