pub trait BorrowMut {
type TargetMut<'a>
where Self: 'a;
// Required method
fn borrow_mut(&mut self) -> Self::TargetMut<'_>;
}
Expand description
Borrow mutably from self.
This works similarly to BorrowMut
but allows borrowing
compoundly from &self
by defining a generic TargetMut
. This means it’s
not just limited to returning an immediate reference to the borrowed value
but can return something which receives lifetime parameters that borrows
from self. This is called “compound borrowing” because it lets you return
types which contains compound references.
It is recommended that you use borrow_mut
instead
of importing this trait.
What about std::borrow::BorrowMut
?
The BorrowMut
trait as defined can’t perform compound
borrows from &mut self
. Because the borrow_mut
method immediately
returns a reference to the borrowed type.
trait BorrowMut<Borrowed: ?Sized>: Borrow<Borrowed> {
fn borrow_mut(&mut self) -> &Borrowed;
}
This means that there is no way to implement something like
BorrowMut<Word<'a>>
because it’s required that we return a reference which
doesn’t outlive 'a
, something that can’t be satisfied from the call to
&mut self
.
struct WordMut<'a>(&'a mut String);
struct OwnedWord(String);
impl<'a> BorrowMut<WordMut<'a>> for OwnedWord {
fn borrow_mut(&mut self) -> &mut WordMut<'a> {
&mut WordMut(&mut self.0)
}
}
error[E0515]: cannot return reference to temporary value
--> src/borrow.rs:37:9
|
9 | &mut WordMut(&mut self.0)
| ^------------------------
| ||
| |temporary value created here
| returns a reference to data owned by the current function
The solution implemented in this crate is to use a generic TargetMut
, with
which we can implement borrow_mut
like this:
use borrowme::BorrowMut;
impl BorrowMut for OwnedWord {
type TargetMut<'a> = WordMut<'a>;
fn borrow_mut(&mut self) -> Self::TargetMut<'_> {
WordMut(&mut self.0)
}
}
A catch here is that BorrowMut
can only be implemented once for each time,
compared to BorrowMut<T>
. But for our purposes this is
fine. This crate is primarily intended to work with two symmetrical types
and any deviation from that pattern can be handled by customizing the
behavior of the #[borrowme]
attribute.
Required Associated Types§
Required Methods§
sourcefn borrow_mut(&mut self) -> Self::TargetMut<'_>
fn borrow_mut(&mut self) -> Self::TargetMut<'_>
Borrow mutably from self
.