Title: Theory / Unimportant / CS / Programming / Rust / Library / Pointer / Pin
On every note of this deck, unless a note says otherwise:
Page: https://doc.rust-lang.org/std/pin/struct.Pin.html

Instruction: Pin<P>::new(pointer)
Returns: A pinned value for pointer
Variables: <P as Deref>::Target: Unpin,

Instruction: Pin<P>::into_inner(pin)
Returns: The value contained in pin, unpinned
Variables: <P as Deref>::Target: Unpin,
pin: Pin<P>

Instruction: Pin<P>::new_unchecked(pointer)
Returns: A pin to value contained in pointer
Variables: P: Deref
Pointer: P
Assuming: value in pointer can never move until the result is unpinned

Instruction: pin.as_ref()
Returns: A pinned reference to the value contained in the pin.
Variables: P: Deref
pin: Pin<P>

Instruction: pin.into_inner_unchecked()
Returns: value in pin
Variables: P: Deref
pin: Pin<P>
Assuming: this value must still be treated as pinned

Instruction: pin.as_mut()
Returns: Pinned mutable reference to the content of pin
Variables: P: DerefMut
pin: Pin<P>

Instruction: pin.set(value)
Returns: Change the value pinned to value
Variables: P: DerefMut
pin: Pin<P>

Instruction: pin.map_unchecked(fn)
Returns: A pinned value to fn(pin_content)
Variables: pin: Pin<'a T>
Assuming: 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.

Instruction: pin.ger_ref()
Returns: A shared reference to the pinned value
Variables: pin: Pin<'a T>

Instruction: pin.into_ref()
Returns: Same pinned reference, not mutable
Variables: pin: Pin<'a mut T>

Instruction: pin.get_mut()
Returns: mutable reference to the pinned data.
Variables: pin: Pin<'a mut T>
Assuming: T is unpin

Instruction: pin.get_unchecked_mut()
Returns: mutable reference to the pinned data.
Variables: pin: Pin<'a mut T>
Assuming: 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.

Instruction: pin.map_unchecked_mut(fn)
Returns: pin of mutable reference to fn(pin's value)
Variables: pin: Pin<'a mut T>
Assuming: 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.

Typ: Pin<T>
Meaning: A pointer to a value of type T, such that this value is guaranteed never to move in memory
Page: https://doc.rust-lang.org/std/pin/struct.Pin.html
Variables: pin: Pin<'a mut T>

Typ: Unpin<T>
Meaning: trait alowing pinned values to be unpinned
Page: https://doc.rust-lang.org/std/pin/struct.Pin.html
Variables: pin: Pin<'a mut T>