# PhantomData

When working with unsafe code, we can often end up in a situation where
types or lifetimes are logically associated with a struct, but not actually
part of a field. This most commonly occurs with lifetimes. For instance, the
`Iter`

for `&'a [T]`

is (approximately) defined as follows:

```
struct Iter<'a, T: 'a> {
ptr: *const T,
end: *const T,
}
```

However because `'a`

is unused within the struct's body, it's *unbounded*.
Because of the troubles this has historically caused, unbounded lifetimes and
types are *forbidden* in struct definitions. Therefore we must somehow refer
to these types in the body. Correctly doing this is necessary to have
correct variance and drop checking.

We do this using `PhantomData`

, which is a special marker type. `PhantomData`

consumes no space, but simulates a field of the given type for the purpose of
static analysis. This was deemed to be less error-prone than explicitly telling
the type-system the kind of variance that you want, while also providing other
useful such as the information needed by drop check.

Iter logically contains a bunch of `&'a T`

s, so this is exactly what we tell
the PhantomData to simulate:

```
use std::marker;
struct Iter<'a, T: 'a> {
ptr: *const T,
end: *const T,
_marker: marker::PhantomData<&'a T>,
}
```

and that's it. The lifetime will be bounded, and your iterator will be variant
over `'a`

and `T`

. Everything Just Works.

Another important example is Vec, which is (approximately) defined as follows:

```
struct Vec<T> {
data: *const T, // *const for variance!
len: usize,
cap: usize,
}
```

Unlike the previous example, it *appears* that everything is exactly as we
want. Every generic argument to Vec shows up in at least one field.
Good to go!

Nope.

The drop checker will generously determine that `Vec<T>`

does not own any values
of type T. This will in turn make it conclude that it doesn't need to worry
about Vec dropping any T's in its destructor for determining drop check
soundness. This will in turn allow people to create unsoundness using
Vec's destructor.

In order to tell dropck that we *do* own values of type T, and therefore may
drop some T's when *we* drop, we must add an extra PhantomData saying exactly
that:

```
use std::marker;
struct Vec<T> {
data: *const T, // *const for covariance!
len: usize,
cap: usize,
_marker: marker::PhantomData<T>,
}
```

Raw pointers that own an allocation is such a pervasive pattern that the
standard library made a utility for itself called `Unique<T>`

which:

- wraps a
`*const T`

for variance - includes a
`PhantomData<T>`

- auto-derives
`Send`

/`Sync`

as if T was contained - marks the pointer as
`NonZero`

for the null-pointer optimization

## Table of `PhantomData`

patterns

Here’s a table of all the wonderful ways `PhantomData`

could be used:

Phantom type | `'a` | `T` |
---|---|---|

`PhantomData<T>` | - | variant (with drop check) |

`PhantomData<&'a T>` | variant | variant |

`PhantomData<&'a mut T>` | variant | invariant |

`PhantomData<*const T>` | - | variant |

`PhantomData<*mut T>` | - | invariant |

`PhantomData<fn(T)>` | - | contravariant (*) |

`PhantomData<fn() -> T>` | - | variant |

`PhantomData<fn(T) -> T>` | - | invariant |

`PhantomData<Cell<&'a ()>>` | invariant | - |

(*) If contravariance gets scrapped, this would be invariant.