Struct std::pin::Pin

#[lang = "pin"]
#[repr(transparent)]
pub struct Pin<P> { /* fields omitted */ }

A pinned pointer.

This is a wrapper around a kind of pointer which makes that pointer "pin" its value in place, preventing the value referenced by that pointer from being moved unless it implements Unpin.

See the pin module documentation for an explanation of pinning.

Methods

impl<P> Pin<P> where
    P: Deref,
    <P as Deref>::Target: Unpin, 

Important traits for Pin<P>

impl<P> Future for Pin<P> where
    P: Unpin + DerefMut,
    <P as Deref>::Target: Future,  type Output = <<P as Deref>::Target as Future>::Output;

pub fn new(pointer: P) -> Pin<P>

Construct a new Pin<P> around a pointer to some data of a type that implements Unpin.

Unlike Pin::new_unchecked, this method is safe because the pointer P dereferences to an Unpin type, which cancels the pinning guarantees.

pub fn into_inner(pin: Pin<P>) -> P

Unwraps this Pin<P> returning the underlying pointer.

This requires that the data inside this Pin is Unpin so that we can ignore the pinning invariants when unwrapping it.

impl<P> Pin<P> where
    P: Deref, 

Important traits for Pin<P>

impl<P> Future for Pin<P> where
    P: Unpin + DerefMut,
    <P as Deref>::Target: Future,  type Output = <<P as Deref>::Target as Future>::Output;

pub unsafe fn new_unchecked(pointer: P) -> Pin<P>

Construct a new Pin<P> around a reference to some data of a type that may or may not implement Unpin.

If pointer dereferences to an Unpin type, Pin::new should be used instead.

Safety

This constructor is unsafe because we cannot guarantee that the data pointed to by pointer is pinned, meaning that the data will not be moved or its storage invalidated until it gets dropped. If the constructed Pin<P> does not guarantee that the data P points to is pinned, that is a violation of the API contract and may lead to undefined behavior in later (safe) operations.

By using this method, you are making a promise about the P::Deref and P::DerefMut implementations, if they exist. Most importantly, they must not move out of their self arguments: Pin::as_mut and Pin::as_ref will call DerefMut::deref_mut and Deref::deref on the pinned pointer and expect these methods to uphold the pinning invariants. Moreover, by calling this method you promise that the reference P dereferences to will not be moved out of again; in particular, it must not be possible to obtain a &mut P::Target and then move out of that reference (using, for example mem::swap).

For example, calling Pin::new_unchecked on an &'a mut T is unsafe because while you are able to pin it for the given lifetime 'a, you have no control over whether it is kept pinned once 'a ends:

use std::mem;
use std::pin::Pin;

fn move_pinned_ref<T>(mut a: T, mut b: T) {
    unsafe {
        let p: Pin<&mut T> = Pin::new_unchecked(&mut a);
        // This should mean the pointee `a` can never move again.
    }
    mem::swap(&mut a, &mut b);
    // The address of `a` changed to `b`'s stack slot, so `a` got moved even
    // though we have previously pinned it! We have violated the pinning API contract.
}

A value, once pinned, must remain pinned forever (unless its type implements Unpin).

Similarily, calling Pin::new_unchecked on an Rc<T> is unsafe because there could be aliases to the same data that are not subject to the pinning restrictions:

use std::rc::Rc;
use std::pin::Pin;

fn move_pinned_rc<T>(mut x: Rc<T>) {
    let pinned = unsafe { Pin::new_unchecked(x.clone()) };
    {
        let p: Pin<&T> = pinned.as_ref();
        // This should mean the pointee can never move again.
    }
    drop(pinned);
    let content = Rc::get_mut(&mut x).unwrap();
    // Now, if `x` was the only reference, we have a mutable reference to
    // data that we pinned above, which we could use to move it as we have
    // seen in the previous example. We have violated the pinning API contract.
 }

Important traits for Pin<P>

impl<P> Future for Pin<P> where
    P: Unpin + DerefMut,
    <P as Deref>::Target: Future,  type Output = <<P as Deref>::Target as Future>::Output;

pub fn as_ref(&self) -> Pin<&<P as Deref>::Target>

Gets a pinned shared reference from this pinned pointer.

This is a generic method to go from &Pin<Pointer<T>> to Pin<&T>. It is safe because, as part of the contract of Pin::new_unchecked, the pointee cannot move after Pin<Pointer<T>> got created. "Malicious" implementations of Pointer::Deref are likewise ruled out by the contract of Pin::new_unchecked.

pub unsafe fn into_inner_unchecked(pin: Pin<P>) -> P

Unwraps this Pin<P> returning the underlying pointer.

Safety

This function is unsafe. You must guarantee that you will continue to treat the pointer P as pinned after you call this function, so that the invariants on the Pin type can be upheld. If the code using the resulting P does not continue to maintain the pinning invariants that is a violation of the API contract and may lead to undefined behavior in later (safe) operations.

If the underlying data is Unpin, Pin::into_inner should be used instead.

impl<P> Pin<P> where
    P: DerefMut, 

Important traits for Pin<P>

impl<P> Future for Pin<P> where
    P: Unpin + DerefMut,
    <P as Deref>::Target: Future,  type Output = <<P as Deref>::Target as Future>::Output;

pub fn as_mut(&mut self) -> Pin<&mut <P as Deref>::Target>

Gets a pinned mutable reference from this pinned pointer.

This is a generic method to go from &mut Pin<Pointer<T>> to Pin<&mut T>. It is safe because, as part of the contract of Pin::new_unchecked, the pointee cannot move after Pin<Pointer<T>> got created. "Malicious" implementations of Pointer::DerefMut are likewise ruled out by the contract of Pin::new_unchecked.

pub fn set(&mut self, value: <P as Deref>::Target) where
    <P as Deref>::Target: Sized, 

Assigns a new value to the memory behind the pinned reference.

This overwrites pinned data, but that is okay: its destructor gets run before being overwritten, so no pinning guarantee is violated.

impl<'a, T> Pin<&'a T> where
    T: ?Sized, 

Important traits for Pin<P>

impl<P> Future for Pin<P> where
    P: Unpin + DerefMut,
    <P as Deref>::Target: Future,  type Output = <<P as Deref>::Target as Future>::Output;

pub unsafe fn map_unchecked<U, F>(self, func: F) -> Pin<&'a U> where
    F: FnOnce(&T) -> &U, 

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.

Important traits for &'_ mut F

impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W

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.

impl<'a, T> Pin<&'a mut T> where
    T: ?Sized, 

Important traits for Pin<P>

impl<P> Future for Pin<P> where
    P: Unpin + DerefMut,
    <P as Deref>::Target: Future,  type Output = <<P as Deref>::Target as Future>::Output;

pub fn into_ref(self) -> Pin<&'a T>

Converts this Pin<&mut T> into a Pin<&T> with the same lifetime.

Important traits for &'_ mut F

impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W

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.

Important traits for &'_ mut F

impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W

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.

Important traits for Pin<P>

impl<P> Future for Pin<P> where
    P: Unpin + DerefMut,
    <P as Deref>::Target: Future,  type Output = <<P as Deref>::Target as Future>::Output;

pub unsafe fn map_unchecked_mut<U, F>(self, func: F) -> Pin<&'a mut U> where
    F: FnOnce(&mut T) -> &mut U, 

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.

Trait Implementations

impl<P> Display for Pin<P> where
    P: Display, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl<P> DerefMut for Pin<P> where
    P: DerefMut,
    <P as Deref>::Target: Unpin, 

fn deref_mut(&mut self) -> &mut <P as Deref>::Target

Mutably dereferences the value.

impl<P> Eq for Pin<P> where
    P: Eq, 

impl<P> Debug for Pin<P> where
    P: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl<P> Deref for Pin<P> where
    P: Deref, 

type Target = <P as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &<P as Deref>::Target

Dereferences the value.

impl<'_, G> Generator for Pin<&'_ mut G> where
    G: Generator + ?Sized, 

type Yield = <G as Generator>::Yield

🔬 This is a nightly-only experimental API. (generator_trait #43122)

The type of value this generator yields.

type Return = <G as Generator>::Return

🔬 This is a nightly-only experimental API. (generator_trait #43122)

The type of value this generator returns.

fn resume(
    self: Pin<&mut Pin<&'_ mut G>>
) -> GeneratorState<<Pin<&'_ mut G> as Generator>::Yield, <Pin<&'_ mut G> as Generator>::Return>

🔬 This is a nightly-only experimental API. (generator_trait #43122)

Resumes the execution of this generator.

impl<P, Q> PartialEq<Pin<Q>> for Pin<P> where
    P: PartialEq<Q>, 

fn eq(&self, other: &Pin<Q>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Pin<Q>) -> bool

This method tests for !=.

impl<P, Q> PartialOrd<Pin<Q>> for Pin<P> where
    P: PartialOrd<Q>, 

fn partial_cmp(&self, other: &Pin<Q>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Pin<Q>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Pin<Q>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Pin<Q>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Pin<Q>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<P> Hash for Pin<P> where
    P: Hash, 

fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<P, U> CoerceUnsized<Pin<U>> for Pin<P> where
    P: CoerceUnsized<U>, 

impl<P, U> DispatchFromDyn<Pin<U>> for Pin<P> where
    P: DispatchFromDyn<U>, 

impl<P> Ord for Pin<P> where
    P: Ord, 

fn cmp(&self, other: &Pin<P>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp #44095)

Restrict a value to a certain interval.

impl<P> Pointer for Pin<P> where
    P: Pointer, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl<P> Clone for Pin<P> where
    P: Clone, 

Important traits for Pin<P>

impl<P> Future for Pin<P> where
    P: Unpin + DerefMut,
    <P as Deref>::Target: Future,  type Output = <<P as Deref>::Target as Future>::Output;

fn clone(&self) -> Pin<P>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P> Future for Pin<P> where
    P: Unpin + DerefMut,
    <P as Deref>::Target: Future, 

type Output = <<P as Deref>::Target as Future>::Output

The type of value produced on completion.

fn poll(
    self: Pin<&mut Pin<P>>,
    cx: &mut Context
) -> Poll<<Pin<P> as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<P> Copy for Pin<P> where
    P: Copy, 

impl<T> From<Box<T>> for Pin<Box<T>> where
    T: ?Sized, 

Important traits for Pin<P>

impl<P> Future for Pin<P> where
    P: Unpin + DerefMut,
    <P as Deref>::Target: Future,  type Output = <<P as Deref>::Target as Future>::Output;

fn from(boxed: Box<T>) -> Pin<Box<T>>

Converts a Box<T> into a Pin<Box<T>>

This conversion does not allocate on the heap and happens in place.

impl<G> Generator for Pin<Box<G>> where
    G: Generator + ?Sized, 

type Yield = <G as Generator>::Yield

🔬 This is a nightly-only experimental API. (generator_trait #43122)

The type of value this generator yields.

type Return = <G as Generator>::Return

🔬 This is a nightly-only experimental API. (generator_trait #43122)

The type of value this generator returns.

fn resume(
    self: Pin<&mut Pin<Box<G>>>
) -> GeneratorState<<Pin<Box<G>> as Generator>::Yield, <Pin<Box<G>> as Generator>::Return>

🔬 This is a nightly-only experimental API. (generator_trait #43122)

Resumes the execution of this generator.