Struct deepmesa_lists::linkedlist::list::FastLinkedList

pub struct FastLinkedList<T> { /* fields omitted */ }

A fast doubly linked list that owns the nodes and can pre-allocate memory for performance. This linked list allows pushing and popping elements at either end or in the middle in constant time.

The API is the same as std::collections::LinkedList however this list also allows pushing and popping elements from the middle of the list in constant time.

This list manages memory via an internal freelist of nodes and capacity is allocated when the list is full. Capacity is deallocated when the list is dropped. This list also vends handles to its nodes that can be used to mutate the list at any node in constant time. The list provides iterators that can use used to traverse the list in either direction by reversing the iterator at any time.

Getting Started

To get started add the deepmesa dependency to Cargo.toml and the use declaration in your source.

[dependencies]
deepmesa = "0.1.0"

use deepmesa::lists::FastLinkedList;

let mut list = FastLinkedList::<u8>::with_capacity(10);
for i in 0..10 {
    list.push_front(i);
}

for e in list.iter() {
    println!("{}", e);
}

Implementations

impl<T> FastLinkedList<T>

pub fn new() -> FastLinkedList<T>

Creates an empty linked list with a default capacity.

Examples

use deepmesa::lists::FastLinkedList;
let list = FastLinkedList::<u8>::new();

pub fn with_capacity(capacity: usize) -> FastLinkedList<T>

Creates an empty linked list with the specified capacity. The list will continue to reallocate additional memory by doubling the capacity everytime the capacity is exceeded.

However the list will not deallocate memory when elements are removed.

If the capacity is set to 0, and the list is full, then new memory will be allocated for one new element everytime an element is added to the list.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
for i in 0..10 {
    // All these are pushed without any allocations
    list.push_front(i);
}

assert_eq!(list.len(), 10);
assert_eq!(list.capacity(), 10);

// This will result in an allocation and the capacity will be doubled
list.push_front(1);
assert_eq!(list.len(), 11);
assert_eq!(list.capacity(), 20);

// A list with a capacity of 0 will allocate on every push
let mut list = FastLinkedList::<u8>::with_capacity(0);
list.push_front(1);
assert_eq!(list.len(), 1);
assert_eq!(list.capacity(), 1);

list.push_front(1);
assert_eq!(list.len(), 2);
assert_eq!(list.capacity(), 2);

pub fn iter(&self) -> Iter<'_, T>

Returns a bidirectional iterator over the list

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::new();
list.push_front(1);
list.push_front(2);
list.push_front(3);
list.push_front(4);
list.push_front(5);

let mut iter = list.iter();
assert_eq!(iter.next(), Some(&5));
assert_eq!(iter.next(), Some(&4));
assert_eq!(iter.next(), Some(&3));
iter = iter.reverse();
assert_eq!(iter.next(), Some(&4));
assert_eq!(iter.next(), Some(&5));
assert_eq!(iter.next(), None);

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a bidirectional iterator over the list with mutable references that allows the value to be modified

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::new();
list.push_front(1);
list.push_front(2);
list.push_front(3);

for e in list.iter_mut() {
    *e += 100;
}

let mut iter = list.iter();
assert_eq!(iter.next(), Some(&103));
assert_eq!(iter.next(), Some(&102));
assert_eq!(iter.next(), Some(&101));
assert_eq!(iter.next(), None);

pub fn clear(&mut self)

Removes and drops all the elements from this list. This has no effect on the allocated capacity of the list. This method should complete in O(n) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
list.push_front(1);
list.push_front(2);
list.push_front(3);

assert_eq!(list.len(), 3);
assert_eq!(list.capacity(), 10);

list.clear();
assert_eq!(list.len(), 0);
assert_eq!(list.capacity(), 10);

pub fn front(&self) -> Option<&T>

Returns a reference to the front (head) of the list or None if the list is empty. This method should complete in O(1) time.

This method simply calls self.head()

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.front(), None);

list.push_front(1);
assert_eq!(list.front(), Some(&1));

pub fn back(&self) -> Option<&T>

Returns a reference to the back (tail) of the list or None if the list is empty. This method should complete in O(1) time.

This method simply calls self.tail()

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.back(), None);

list.push_back(1);
assert_eq!(list.back(), Some(&1));

pub fn front_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the front (head) of the list or None if the list is empty. This method should complete in O(1) time.

This method simply calls self.head_mut()

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.front(), None);

list.push_front(1);
assert_eq!(list.front(), Some(&1));
match list.front_mut() {
    None => {},
    Some(x) => *x = 5,
}
assert_eq!(list.front(), Some(&5));

pub fn back_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the back (tail) of the list or None if the list is empty. This method should complete in O(1) time.

This method simply calls self.tail_mut()

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.back(), None);

list.push_back(1);
assert_eq!(list.back(), Some(&1));
match list.back_mut() {
    None => {},
    Some(x) => *x = 5,
}
assert_eq!(list.back(), Some(&5));

pub fn tail(&self) -> Option<&T>

Returns a reference to the back (tail) of the list or None if the list is empty. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.tail(), None);

list.push_tail(1);
assert_eq!(list.tail(), Some(&1));

pub fn tail_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the back (tail) of the list or None if the list is empty. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.tail(), None);

list.push_tail(1);
assert_eq!(list.tail(), Some(&1));
match list.tail_mut() {
    None => {},
    Some(x) => *x = 5,
}
assert_eq!(list.tail(), Some(&5));

pub fn head(&self) -> Option<&T>

Returns a reference to the front (head) of the list or None if the list is empty. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.head(), None);

list.push_head(1);
assert_eq!(list.head(), Some(&1));

pub fn head_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the front (head) of the list or None if the list is empty. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.head(), None);

list.push_head(1);
assert_eq!(list.head(), Some(&1));
match list.head_mut() {
    None => {},
    Some(x) => *x = 5,
}
assert_eq!(list.head(), Some(&5));

pub fn next(&self, node: &Node<T>) -> Option<&T>

Returns a reference to the value of the node immediately after the node associated with the specified handle. If the specified handle is invalid or there is no next node, this method returns None. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
list.push_head(1);
let node = list.push_head(2);

assert_eq!(list.next(&node), Some(&1));

list.pop_tail();
// once the tail is popped, there is no next
assert_eq!(list.next(&node), None);

pub fn next_mut(&mut self, node: &Node<T>) -> Option<&mut T>

Returns a mutable reference to the value of the node immediately after the node associated with the specified handle. If the specified handle is invalid or if there is no next node, this method returns None. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
list.push_head(1);
let node = list.push_head(2);
assert_eq!(list.next(&node), Some(&1));

match list.next_mut(&node) {
    None => {},
    Some(x) => *x = 100,
}

assert_eq!(list.next(&node), Some(&100));

pub fn prev(&self, node: &Node<T>) -> Option<&T>

Returns a reference to the value of the node immediately preceeding the node associated with the specified handle. If the specified handle is invalid or if there is no preceeding node, this method returns None. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node = list.push_head(1);
list.push_head(2);

assert_eq!(list.prev(&node), Some(&2));

list.pop_head();
// once the head is popped, there is no prev
assert_eq!(list.prev(&node), None);

pub fn prev_mut(&mut self, node: &Node<T>) -> Option<&mut T>

Returns a mutable reference to the value of the node immediately preceeding the node associated with the specified handle. If the specified handle is invalid or there is no preceeding node, this method returns None. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node = list.push_head(1);
list.push_head(2);
assert_eq!(list.prev(&node), Some(&2));

match list.prev_mut(&node) {
    None => {},
    Some(x) => *x = 100,
}

assert_eq!(list.prev(&node), Some(&100));

pub fn prev_node(&self, node: &Node<T>) -> Option<Node<T>>

Returns a handle to the node immediately preceeding the node associated with the specified handle. If the specified handle is invalid or if there is no preceeding node, this method returns None. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node = list.push_head(1);
list.push_head(2);

assert_eq!(list.prev(&node), Some(&2));

list.pop_head();
//once the head is popped there is no prev node
assert_eq!(list.prev(&node), None);

pub fn next_node(&self, node: &Node<T>) -> Option<Node<T>>

Returns a handle to the node immediately preceeding the node associated with the specified handle. If the handle is invalid or if there is no preceeding node, this method returns None. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
list.push_head(1);
let node = list.push_head(2);

match list.next_node(&node) {
    None => {},
    Some(n) => assert_eq!(list.node(&n), Some(&1)),
}

list.pop_tail();
// Once the tail node is popped, there is no next node
assert_eq!(list.next_node(&node), None);

pub fn node(&self, node: &Node<T>) -> Option<&T>

Returns a reference to the value of the node associated with the specified handle. If the specified handle is invalid this method returns None. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node = list.push_head(1);

assert_eq!(list.node(&node), Some(&1));

list.pop_head();
// once the node is popped the handle becomes invalid
assert_eq!(list.node(&node), None);

pub fn node_mut(&mut self, node: &Node<T>) -> Option<&mut T>

Returns a mutable reference to the value of the node associated with the specified handle. If the specified handle is invalid this method returns None. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node = list.push_head(1);

assert_eq!(list.node(&node), Some(&1));

match list.node_mut(&node) {
    None => {},
    Some(x) => *x = 100,
}

assert_eq!(list.node(&node), Some(&100));

pub fn head_node(&self) -> Option<Node<T>>

Returns a handle to the head (front) of the list or None if the list is empty. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node = list.push_head(1);

match list.head_node() {
    None => {},
    Some(x) => assert_eq!(list.node(&x), Some(&1)),
}

list.pop_head();
assert_eq!(list.head_node(), None);

pub fn tail_node(&self) -> Option<Node<T>>

Returns a handle to the tail (back) of the list or None if the list is empty. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node = list.push_tail(1);

match list.tail_node() {
    None => {},
    Some(x) => assert_eq!(list.node(&x), Some(&1)),
}

list.pop_tail();
assert_eq!(list.tail_node(), None);

pub fn has_next(&self, node: &Node<T>) -> Option<bool>

Returns true if the node associated with the specified handle has a next node and false if it does not. If the specified handle is invalid this method returns None. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node1 = list.push_head(1);
let node2 = list.push_head(2);

assert_eq!(list.has_next(&node1), Some(false));
assert_eq!(list.has_next(&node2), Some(true));

list.pop_head();
assert_eq!(list.has_next(&node1), Some(false));
// once the head is popped node2 becomes an invalid handle
assert_eq!(list.has_next(&node2), None);

pub fn has_prev(&self, node: &Node<T>) -> Option<bool>

Returns true if the node associated with the specified handle has a previous node and false if it does not. If the specified handle is invalid this method returns None. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node1 = list.push_head(1);
let node2 = list.push_head(2);

assert_eq!(list.has_prev(&node1), Some(true));
assert_eq!(list.has_prev(&node2), Some(false));

list.pop_head();
assert_eq!(list.has_prev(&node1), Some(false));
// once the head is popped node2 becomes an invalid handle
assert_eq!(list.has_next(&node2), None);

pub fn is_empty(&self) -> bool

Returns true if the list is empty. This method should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.is_empty(), true);

list.push_head(1);
assert_eq!(list.is_empty(), false);

pub fn has_head(&self) -> bool

Returns true if the list has a head node and false if the list is empty.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.has_head(), false);
list.push_head(1);
assert_eq!(list.has_head(), true);
list.pop_head();
assert_eq!(list.has_head(), false);

pub fn has_tail(&self) -> bool

Returns true if the list has a tail node and false if the list is empty.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.has_tail(), false);
list.push_tail(1);
assert_eq!(list.has_tail(), true);
list.pop_tail();
assert_eq!(list.has_tail(), false);

pub fn capacity(&self) -> usize

Returns the number of elements the list can hold without before new memory is allocated.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.capacity(), 10);

pub fn len(&self) -> usize

Returns the number of elements in the list

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.len(), 0);

list.push_head(1);
assert_eq!(list.len(), 1);

pub fn push_front(&mut self, elem: T)

Adds an element to the front (head) of the list. This operation should complete in O(1) time.

This method simply calls self.push_head()

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
list.push_front(1);
assert_eq!(list.front(), Some(&1));

list.push_front(2);
assert_eq!(list.front(), Some(&2));

pub fn push_back(&mut self, elem: T)

Adds an element to the back (tail) of the list. This operation should complete in O(1) time.

This method simply calls self.push_tail()

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
list.push_back(1);
assert_eq!(list.back(), Some(&1));

list.push_back(2);
assert_eq!(list.back(), Some(&2));

pub fn pop_head(&mut self) -> Option<T>

Removes and returns the value at the head (front) of the list or None if the list is empty. This operation should complete in O(1) time

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.pop_head(), None);

list.push_head(1);
list.push_head(2);
assert_eq!(list.pop_head(), Some(2));
assert_eq!(list.pop_head(), Some(1));
assert_eq!(list.pop_head(), None);

pub fn pop_tail(&mut self) -> Option<T>

Removes and returns the value at the tail (back) of the list or None if the list is empty. This operation should complete in O(1) time

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.pop_tail(), None);

list.push_tail(1);
list.push_tail(2);
assert_eq!(list.pop_tail(), Some(2));
assert_eq!(list.pop_tail(), Some(1));
assert_eq!(list.pop_tail(), None);

pub fn pop_front(&mut self) -> Option<T>

Removes and returns the value at the front (head) of the list or None if the list is empty. This operation should complete in O(1) time.

This method simply calls self.pop_head()

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.pop_front(), None);

list.push_front(1);
list.push_front(2);
assert_eq!(list.pop_front(), Some(2));
assert_eq!(list.pop_front(), Some(1));
assert_eq!(list.pop_front(), None);

pub fn pop_back(&mut self) -> Option<T>

Removes and returns the value at the back (tail) of the list or None if the list is empty. This operation should complete in O(1) time

This method simply calls self.pop_tail()

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
assert_eq!(list.pop_back(), None);

list.push_back(1);
list.push_back(2);
assert_eq!(list.pop_back(), Some(2));
assert_eq!(list.pop_back(), Some(1));
assert_eq!(list.pop_back(), None);

pub fn pop_next(&mut self, node: &Node<T>) -> Option<T>

Removes and returns the value of the node immediately after the node associated with the specified handle. If the specified handle is invalid or there is no next node, then this method returns None.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);

list.push_head(1);
list.push_head(2);
let node = list.push_head(3);
assert_eq!(list.pop_next(&node), Some(2));
assert_eq!(list.pop_next(&node), Some(1));
assert_eq!(list.pop_next(&node), None);

pub fn pop_prev(&mut self, node: &Node<T>) -> Option<T>

Removes and returns the value of the node immediately preceeding the node associated with the specified handle. If the specified handle is invalid or there is no previous node, then this method returns None.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);

let node = list.push_head(1);
list.push_head(2);
list.push_head(3);
assert_eq!(list.pop_prev(&node), Some(2));
assert_eq!(list.pop_prev(&node), Some(3));
assert_eq!(list.pop_prev(&node), None);

pub fn pop_node(&mut self, node: &Node<T>) -> Option<T>

Removes and returns the value of the node associated with the specified handle. If the specified handle is invalid then this method returns None.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);

let node = list.push_head(1);
assert_eq!(list.pop_node(&node), Some(1));
assert_eq!(list.pop_node(&node), None);

pub fn push_head(&mut self, elem: T) -> Node<T>

Adds an element to the head (front) of the list and returns a handle to it. This operation should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node = list.push_head(1);
assert_eq!(list.node(&node), Some(&1));

pub fn push_tail(&mut self, elem: T) -> Node<T>

Adds an element to the tail (back) of the list and returns a handle to it. This operation should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
let node = list.push_tail(1);
assert_eq!(list.node(&node), Some(&1));

pub fn contains(&self, x: &T) -> bool where
    T: PartialEq<T>, 

Returns true if the LinkedList contains an element equal to the given value.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);

list.push_back(0);
list.push_back(1);
list.push_back(2);

assert_eq!(list.contains(&0), true);
assert_eq!(list.contains(&10), false);

pub fn push_next(&mut self, node: &Node<T>, elem: T) -> Option<Node<T>>

Adds an element immediately after the node associated with the specified handle. Returns the handle to the node thats been added or None if the specified handle is invalid. This operation should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);

list.push_head(0);
let middle = list.push_head(1);
list.push_head(2);
list.push_next(&middle, 100);

let mut iter = list.iter();
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&100));
assert_eq!(iter.next(), Some(&0));
assert_eq!(iter.next(), None);

pub fn push_prev(&mut self, node: &Node<T>, elem: T) -> Option<Node<T>>

Adds an element immediately preceedeing the node associated with the specified handle. Returns the handle to the node thats been added or None if the specified handle is invalid. This operation should complete in O(1) time.

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);

list.push_head(0);
let middle = list.push_head(1);
list.push_head(2);
list.push_prev(&middle, 100);

let mut iter = list.iter();
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), Some(&100));
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&0));
assert_eq!(iter.next(), None);

pub fn append(&mut self, other: &mut Self)

Moves all nodes from the other list to the end of this list. After this operation completes, the other list is empty and all the nodes from that list have been moved into this one.

All handles to nodes previously returned by other list will become invalid after this operation completes.

This operation has no effect on the allocated capacity of either list. This operation should compute in O(1) time

Examples

use deepmesa::lists::FastLinkedList;
let mut list = FastLinkedList::<u8>::with_capacity(10);
list.push_back(0);

let mut list2 = FastLinkedList::<u8>::with_capacity(10);
list2.push_back(1);
list2.push_back(2);

list.append(&mut list2);

let mut iter = list.iter();
assert_eq!(iter.next(), Some(&0));
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), None);

assert_eq!(list.len(), 3);
assert!(list2.is_empty());

Trait Implementations

impl<T: Debug> Debug for FastLinkedList<T>

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

Formats the value using the given formatter.

impl<T> Drop for FastLinkedList<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> IntoIterator for &'a FastLinkedList<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut FastLinkedList<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.