Expand description
References, both shared and mutable.
A reference represents a borrow of some owned value. You can get one by using the &
or &mut
operators on a value, or by using a ref
or
ref mut
pattern.
For those familiar with pointers, a reference is just a pointer that is assumed to be
aligned, not null, and pointing to memory containing a valid value of T
- for example,
&bool
can only point to an allocation containing the integer values 1
(true
) or 0
(false
), but
creating a &bool
that points to an allocation containing
the value 3
causes undefined behaviour.
In fact, Option<&T>
has the same memory representation as a
nullable but aligned pointer, and can be passed across FFI boundaries as such.
In most cases, references can be used much like the original value. Field access, method calling, and indexing work the same (save for mutability rules, of course). In addition, the comparison operators transparently defer to the referent’s implementation, allowing references to be compared the same as owned values.
References have a lifetime attached to them, which represents the scope for which the borrow is
valid. A lifetime is said to “outlive” another one if its representative scope is as long or
longer than the other. The 'static
lifetime is the longest lifetime, which represents the
total life of the program. For example, string literals have a 'static
lifetime because the
text data is embedded into the binary of the program, rather than in an allocation that needs
to be dynamically managed.
&mut T
references can be freely coerced into &T
references with the same referent type, and
references with longer lifetimes can be freely coerced into references with shorter ones.
Reference equality by address, instead of comparing the values pointed to, is accomplished via
implicit reference-pointer coercion and raw pointer equality via ptr::eq
, while
PartialEq
compares values.
use std::ptr;
let five = 5;
let other_five = 5;
let five_ref = &five;
let same_five_ref = &five;
let other_five_ref = &other_five;
assert!(five_ref == same_five_ref);
assert!(five_ref == other_five_ref);
assert!(ptr::eq(five_ref, same_five_ref));
assert!(!ptr::eq(five_ref, other_five_ref));
RunFor more information on how to use references, see the book’s section on “References and Borrowing”.
Trait implementations
The following traits are implemented for all &T
, regardless of the type of its referent:
Copy
Clone
(Note that this will not defer toT
’sClone
implementation if it exists!)Deref
Borrow
fmt::Pointer
&mut T
references get all of the above except Copy
and Clone
(to prevent creating
multiple simultaneous mutable borrows), plus the following, regardless of the type of its
referent:
The following traits are implemented on &T
references if the underlying T
also implements
that trait:
- All the traits in
std::fmt
exceptfmt::Pointer
(which is implemented regardless of the type of its referent) andfmt::Write
PartialOrd
Ord
PartialEq
Eq
AsRef
Fn
(in addition,&T
references getFnMut
andFnOnce
ifT: Fn
)Hash
ToSocketAddrs
Send
(&T
references also requireT: Sync
)
&mut T
references get all of the above except ToSocketAddrs
, plus the following, if T
implements that trait:
AsMut
FnMut
(in addition,&mut T
references getFnOnce
ifT: FnMut
)fmt::Write
Iterator
DoubleEndedIterator
ExactSizeIterator
FusedIterator
TrustedLen
io::Write
Read
Seek
BufRead
Note that due to method call deref coercion, simply calling a trait method will act like they
work on references as well as they do on owned values! The implementations described here are
meant for generic contexts, where the final type T
is a type parameter or otherwise not
locally known.
Implementations
sourceimpl<'a, T: ?Sized> Pin<&'a T>
impl<'a, T: ?Sized> Pin<&'a T>
1.33.0 · sourcepub unsafe fn map_unchecked<U, F>(self, func: F) -> Pin<&'a U>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
where
U: ?Sized,
F: FnOnce(&T) -> &U,
pub unsafe fn map_unchecked<U, F>(self, func: F) -> Pin<&'a U>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
where
U: ?Sized,
F: FnOnce(&T) -> &U,
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
Constructs a new pin by mapping the interior value.
For example, if you wanted to get a Pin
of a field of something,
you could use this to get access to that field in one line of code.
However, there are several gotchas with these “pinning projections”;
see the pin
module documentation for further details on that topic.
Safety
This function is unsafe. You must guarantee that the data you return will not move so long as the argument value does not move (for example, because it is one of the fields of that value), and also that you do not move out of the argument you receive to the interior function.
1.33.0 (const: unstable) · sourcepub fn get_ref(self) -> &'a T
pub fn get_ref(self) -> &'a T
Gets a shared reference out of a pin.
This is safe because it is not possible to move out of a shared reference.
It may seem like there is an issue here with interior mutability: in fact,
it is possible to move a T
out of a &RefCell<T>
. However, this is
not a problem as long as there does not also exist a Pin<&T>
pointing
to the same data, and RefCell<T>
does not let you create a pinned reference
to its contents. See the discussion on “pinning projections” for further
details.
Note: Pin
also implements Deref
to the target, which can be used
to access the inner value. However, Deref
only provides a reference
that lives for as long as the borrow of the Pin
, not the lifetime of
the Pin
itself. This method allows turning the Pin
into a reference
with the same lifetime as the original Pin
.
sourceimpl<'a, T: ?Sized> Pin<&'a mut T>
impl<'a, T: ?Sized> Pin<&'a mut T>
1.33.0 (const: unstable) · sourcepub fn into_ref(self) -> Pin<&'a T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
pub fn into_ref(self) -> Pin<&'a T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
Converts this Pin<&mut T>
into a Pin<&T>
with the same lifetime.
1.33.0 (const: unstable) · sourcepub fn get_mut(self) -> &'a mut T where
T: Unpin,
pub fn get_mut(self) -> &'a mut T where
T: Unpin,
Gets a mutable reference to the data inside of this Pin
.
This requires that the data inside this Pin
is Unpin
.
Note: Pin
also implements DerefMut
to the data, which can be used
to access the inner value. However, DerefMut
only provides a reference
that lives for as long as the borrow of the Pin
, not the lifetime of
the Pin
itself. This method allows turning the Pin
into a reference
with the same lifetime as the original Pin
.
1.33.0 (const: unstable) · sourcepub unsafe fn get_unchecked_mut(self) -> &'a mut T
pub unsafe fn get_unchecked_mut(self) -> &'a mut T
Gets a mutable reference to the data inside of this Pin
.
Safety
This function is unsafe. You must guarantee that you will never move
the data out of the mutable reference you receive when you call this
function, so that the invariants on the Pin
type can be upheld.
If the underlying data is Unpin
, Pin::get_mut
should be used
instead.
1.33.0 · sourcepub unsafe fn map_unchecked_mut<U, F>(self, func: F) -> Pin<&'a mut U>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
where
U: ?Sized,
F: FnOnce(&mut T) -> &mut U,
pub unsafe fn map_unchecked_mut<U, F>(self, func: F) -> Pin<&'a mut U>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
where
U: ?Sized,
F: FnOnce(&mut T) -> &mut U,
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
Construct a new pin by mapping the interior value.
For example, if you wanted to get a Pin
of a field of something,
you could use this to get access to that field in one line of code.
However, there are several gotchas with these “pinning projections”;
see the pin
module documentation for further details on that topic.
Safety
This function is unsafe. You must guarantee that the data you return will not move so long as the argument value does not move (for example, because it is one of the fields of that value), and also that you do not move out of the argument you receive to the interior function.
sourceimpl<T: ?Sized> Pin<&'static T>
impl<T: ?Sized> Pin<&'static T>
1.61.0 (const: unstable) · sourcepub fn static_ref(r: &'static T) -> Pin<&'static T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
pub fn static_ref(r: &'static T) -> Pin<&'static T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
Get a pinned reference from a static reference.
This is safe, because T
is borrowed for the 'static
lifetime, which
never ends.
sourceimpl<T: ?Sized> Pin<&'static mut T>
impl<T: ?Sized> Pin<&'static mut T>
1.61.0 (const: unstable) · sourcepub fn static_mut(r: &'static mut T) -> Pin<&'static mut T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
pub fn static_mut(r: &'static mut T) -> Pin<&'static mut T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut<Target: Future>, type Output = <<P as Deref>::Target as Future>::Output;
Get a pinned mutable reference from a static mutable reference.
This is safe, because T
is borrowed for the 'static
lifetime, which
never ends.
Trait Implementations
sourceimpl<G: ?Sized + Generator<R>, R> Generator<R> for Pin<&mut G>
impl<G: ?Sized + Generator<R>, R> Generator<R> for Pin<&mut G>
sourceimpl<A: ?Sized, B: ?Sized> PartialOrd<&'_ B> for &A where
A: PartialOrd<B>,
impl<A: ?Sized, B: ?Sized> PartialOrd<&'_ B> for &A where
A: PartialOrd<B>,
sourcefn partial_cmp(&self, other: &&B) -> Option<Ordering>
fn partial_cmp(&self, other: &&B) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
sourcefn lt(&self, other: &&B) -> bool
fn lt(&self, other: &&B) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
sourcefn le(&self, other: &&B) -> bool
fn le(&self, other: &&B) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl<A: ?Sized, B: ?Sized> PartialOrd<&'_ mut B> for &mut A where
A: PartialOrd<B>,
impl<A: ?Sized, B: ?Sized> PartialOrd<&'_ mut B> for &mut A where
A: PartialOrd<B>,
sourcefn partial_cmp(&self, other: &&mut B) -> Option<Ordering>
fn partial_cmp(&self, other: &&mut B) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
sourcefn lt(&self, other: &&mut B) -> bool
fn lt(&self, other: &&mut B) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
sourcefn le(&self, other: &&mut B) -> bool
fn le(&self, other: &&mut B) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more