Unpin and Its Implications

In this lesson, you will learn why most types in Rust are automatically Unpin and how this marker trait makes memory safety possible when moving data.

The Problem with Self-Referential Data

As we discussed in our previous session on self-referential structs, some types (like async state machines) contain pointers that reference their own fields. If you move such a struct in memory, those internal pointers become "dangling"—they point to the old memory address where the data used to live. Pin was created to lock these sensitive types in place, preventing them from being moved.

What is Unpin?

However, if we locked everything in place, Rust would become incredibly difficult to use. Most types in Rust—like i32, String, or a simple struct—do not contain internal pointers to themselves. Moving them is perfectly safe because their internal data doesn't depend on their specific memory address.

Unpin is a special marker trait that acts as an "opt-out" for the restrictions of Pin.

• If a type is Unpin, it means: "I am safe to move even if I am currently wrapped in a Pin pointer."
• Almost every type in Rust implements Unpin by default.

A Concrete Illustration

When you wrap a type T in Pin<Box<T>>, Rust checks if T implements Unpin. If it does, Pin essentially does nothing to restrict you; it treats the data as if it were a regular Box.

use std::marker::Unpin;

// A standard struct is Unpin by default.
struct MyData {
    value: i32,
}

fn main() {
    let boxed = Box::new(MyData { value: 42 });
    let pinned = Box::pin(boxed); 
    
    // Because MyData is Unpin, we can move the data 
    // out of the Pin without breaking memory safety.
    let unpinned_data = *pinned;
}

If you ever create a type that is not Unpin (usually by using PhantomPinned), you lose the ability to move it once it has been pinned. Unpin is the safety contract that tells the compiler: "I don't have internal references, so feel free to move me around."

Key Takeaway: The Unpin trait is a marker that tells the compiler a type is safe to move, allowing developers to bypass the strict pinning requirements for standard, non-self-referential data.