W3cubDocs

/Rust

Struct std::collections::LinkedList

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

A doubly-linked list with owned nodes.

The LinkedList allows pushing and popping elements at either end in constant time.

NOTE: It is almost always better to use Vec or VecDeque because array-based containers are generally faster, more memory efficient, and make better use of CPU cache.

Implementations

`impl<T> LinkedList<T>`[src]

`pub const fn new() -> LinkedList<T>`[src]

Creates an empty LinkedList.

Examples

use std::collections::LinkedList;

let list: LinkedList<u32> = LinkedList::new();

`pub fn append(&mut self, other: &mut LinkedList<T>)`[src]

Moves all elements from other to the end of the list.

This reuses all the nodes from other and moves them into self. After this operation, other becomes empty.

This operation should compute in O(1) time and O(1) memory.

Examples

use std::collections::LinkedList;

let mut list1 = LinkedList::new();
list1.push_back('a');

let mut list2 = LinkedList::new();
list2.push_back('b');
list2.push_back('c');

list1.append(&mut list2);

let mut iter = list1.iter();
assert_eq!(iter.next(), Some(&'a'));
assert_eq!(iter.next(), Some(&'b'));
assert_eq!(iter.next(), Some(&'c'));
assert!(iter.next().is_none());

assert!(list2.is_empty());

`pub fn prepend(&mut self, other: &mut LinkedList<T>)`[src]

🔬 This is a nightly-only experimental API. (linked_list_prepend)

Moves all elements from other to the begin of the list.

pub fn iter(&self) -> Iter<'_, T>ⓘNotable traits for Iter<'a, T>
impl<'a, T> Iterator for Iter<'a, T>
    type Item = &'a T;

[src]

Provides a forward iterator.

Examples

use std::collections::LinkedList;

let mut list: LinkedList<u32> = LinkedList::new();

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

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);

pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘNotable traits for IterMut<'a, T>
impl<'a, T> Iterator for IterMut<'a, T>
    type Item = &'a mut T;

[src]

Provides a forward iterator with mutable references.

Examples

use std::collections::LinkedList;

let mut list: LinkedList<u32> = LinkedList::new();

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

for element in list.iter_mut() {
    *element += 10;
}

let mut iter = list.iter();
assert_eq!(iter.next(), Some(&10));
assert_eq!(iter.next(), Some(&11));
assert_eq!(iter.next(), Some(&12));
assert_eq!(iter.next(), None);

`pub fn cursor_front(&self) -> Cursor<'_, T>`[src]

🔬 This is a nightly-only experimental API. (linked_list_cursors #58533)

Provides a cursor at the front element.

The cursor is pointing to the "ghost" non-element if the list is empty.

`pub fn cursor_front_mut(&mut self) -> CursorMut<'_, T>`[src]

🔬 This is a nightly-only experimental API. (linked_list_cursors #58533)

Provides a cursor with editing operations at the front element.

The cursor is pointing to the "ghost" non-element if the list is empty.

`pub fn cursor_back(&self) -> Cursor<'_, T>`[src]

🔬 This is a nightly-only experimental API. (linked_list_cursors #58533)

Provides a cursor at the back element.

The cursor is pointing to the "ghost" non-element if the list is empty.

`pub fn cursor_back_mut(&mut self) -> CursorMut<'_, T>`[src]

🔬 This is a nightly-only experimental API. (linked_list_cursors #58533)

Provides a cursor with editing operations at the back element.

The cursor is pointing to the "ghost" non-element if the list is empty.

`pub fn is_empty(&self) -> bool`[src]

Returns true if the LinkedList is empty.

This operation should compute in O(1) time.

Examples

use std::collections::LinkedList;

let mut dl = LinkedList::new();
assert!(dl.is_empty());

dl.push_front("foo");
assert!(!dl.is_empty());

`pub fn len(&self) -> usize`[src]

Returns the length of the LinkedList.

This operation should compute in O(1) time.

Examples

use std::collections::LinkedList;

let mut dl = LinkedList::new();

dl.push_front(2);
assert_eq!(dl.len(), 1);

dl.push_front(1);
assert_eq!(dl.len(), 2);

dl.push_back(3);
assert_eq!(dl.len(), 3);

`pub fn clear(&mut self)`[src]

Removes all elements from the LinkedList.

This operation should compute in O(n) time.

Examples

use std::collections::LinkedList;

let mut dl = LinkedList::new();

dl.push_front(2);
dl.push_front(1);
assert_eq!(dl.len(), 2);
assert_eq!(dl.front(), Some(&1));

dl.clear();
assert_eq!(dl.len(), 0);
assert_eq!(dl.front(), None);

`pub fn contains(&self, x: &T) -> bool where T: PartialEq<T>,` [src]1.12.0

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

Examples

use std::collections::LinkedList;

let mut list: LinkedList<u32> = LinkedList::new();

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 front(&self) -> Option<&T>`[src]

Provides a reference to the front element, or None if the list is empty.

Examples

use std::collections::LinkedList;

let mut dl = LinkedList::new();
assert_eq!(dl.front(), None);

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

`pub fn front_mut(&mut self) -> Option<&mut T>`[src]

Provides a mutable reference to the front element, or None if the list is empty.

Examples

use std::collections::LinkedList;

let mut dl = LinkedList::new();
assert_eq!(dl.front(), None);

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

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

`pub fn back(&self) -> Option<&T>`[src]

Provides a reference to the back element, or None if the list is empty.

Examples

use std::collections::LinkedList;

let mut dl = LinkedList::new();
assert_eq!(dl.back(), None);

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

`pub fn back_mut(&mut self) -> Option<&mut T>`[src]

Provides a mutable reference to the back element, or None if the list is empty.

Examples

use std::collections::LinkedList;

let mut dl = LinkedList::new();
assert_eq!(dl.back(), None);

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

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

`pub fn push_front(&mut self, elt: T)`[src]

Adds an element first in the list.

This operation should compute in O(1) time.

Examples

use std::collections::LinkedList;

let mut dl = LinkedList::new();

dl.push_front(2);
assert_eq!(dl.front().unwrap(), &2);

dl.push_front(1);
assert_eq!(dl.front().unwrap(), &1);

`pub fn pop_front(&mut self) -> Option<T>`[src]

Removes the first element and returns it, or None if the list is empty.

This operation should compute in O(1) time.

Examples

use std::collections::LinkedList;

let mut d = LinkedList::new();
assert_eq!(d.pop_front(), None);

d.push_front(1);
d.push_front(3);
assert_eq!(d.pop_front(), Some(3));
assert_eq!(d.pop_front(), Some(1));
assert_eq!(d.pop_front(), None);

`pub fn push_back(&mut self, elt: T)`[src]

Appends an element to the back of a list.

This operation should compute in O(1) time.

Examples

use std::collections::LinkedList;

let mut d = LinkedList::new();
d.push_back(1);
d.push_back(3);
assert_eq!(3, *d.back().unwrap());

`pub fn pop_back(&mut self) -> Option<T>`[src]

Removes the last element from a list and returns it, or None if it is empty.

This operation should compute in O(1) time.

Examples

use std::collections::LinkedList;

let mut d = LinkedList::new();
assert_eq!(d.pop_back(), None);
d.push_back(1);
d.push_back(3);
assert_eq!(d.pop_back(), Some(3));

`pub fn split_off(&mut self, at: usize) -> LinkedList<T>`[src]

Splits the list into two at the given index. Returns everything after the given index, including the index.

This operation should compute in O(n) time.

Panics

Panics if at > len.

Examples

use std::collections::LinkedList;

let mut d = LinkedList::new();

d.push_front(1);
d.push_front(2);
d.push_front(3);

let mut split = d.split_off(2);

assert_eq!(split.pop_front(), Some(1));
assert_eq!(split.pop_front(), None);

`pub fn remove(&mut self, at: usize) -> T`[src]

🔬 This is a nightly-only experimental API. (linked_list_remove #69210)

Removes the element at the given index and returns it.

This operation should compute in O(n) time.

Panics

Panics if at >= len

Examples

#![feature(linked_list_remove)]
use std::collections::LinkedList;

let mut d = LinkedList::new();

d.push_front(1);
d.push_front(2);
d.push_front(3);

assert_eq!(d.remove(1), 2);
assert_eq!(d.remove(0), 3);
assert_eq!(d.remove(0), 1);

pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F>ⓘNotable traits for DrainFilter<'_, T, F>
impl<'_, T, F> Iterator for DrainFilter<'_, T, F> where
    F: FnMut(&mut T) -> bool, 
    type Item = T;
 where
    F: FnMut(&mut T) -> bool,

[src]

🔬 This is a nightly-only experimental API. (drain_filter #43244)recently added

Creates an iterator which uses a closure to determine if an element should be removed.

If the closure returns true, then the element is removed and yielded. If the closure returns false, the element will remain in the list and will not be yielded by the iterator.

Note that drain_filter lets you mutate every element in the filter closure, regardless of whether you choose to keep or remove it.

Examples

Splitting a list into evens and odds, reusing the original list:

#![feature(drain_filter)]
use std::collections::LinkedList;

let mut numbers: LinkedList<u32> = LinkedList::new();
numbers.extend(&[1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]);

let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<LinkedList<_>>();
let odds = numbers;

assert_eq!(evens.into_iter().collect::<Vec<_>>(), vec![2, 4, 6, 8, 14]);
assert_eq!(odds.into_iter().collect::<Vec<_>>(), vec![1, 3, 5, 9, 11, 13, 15]);

Trait Implementations

`impl<T> Clone for LinkedList<T> where T: Clone,` [src]

`fn clone(&self) -> LinkedList<T>`[src]

`fn clone_from(&mut self, other: &LinkedList<T>)`[src]

`impl<T> Debug for LinkedList<T> where T: Debug,` [src]

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<T> Default for LinkedList<T>`[src]

`fn default() -> LinkedList<T>`[src]

Creates an empty LinkedList<T>.

`impl<T> Drop for LinkedList<T>`[src]

`fn drop(&mut self)`[src]

`impl<T> Eq for LinkedList<T> where T: Eq,` [src]

`impl<'a, T> Extend<&'a T> for LinkedList<T> where T: 'a + Copy,` [src]1.2.0

`fn extend(&mut self, iter: I) where I: IntoIterator<Item = &'a T>,` [src]

`fn extend_one(&mut self, &'a T)`[src]

`fn extend_reserve(&mut self, additional: usize)`[src]

`impl<T> Extend<T> for LinkedList<T>`[src]

`fn extend(&mut self, iter: I) where I: IntoIterator<Item = T>,` [src]

`fn extend_one(&mut self, elem: T)`[src]

`fn extend_reserve(&mut self, additional: usize)`[src]

`impl<T> FromIterator<T> for LinkedList<T>`[src]

`fn from_iter(iter: I) -> LinkedList<T> where I: IntoIterator<Item = T>,` [src]

`impl<T> Hash for LinkedList<T> where T: Hash,` [src]

`fn hash<H>(&self, state: &mut H) where H: Hasher,` [src]

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

`impl<'a, T> IntoIterator for &'a LinkedList<T>`[src]

`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) -> Iter<'a, T>ⓘNotable traits for Iter<'a, T>
impl<'a, T> Iterator for Iter<'a, T>
    type Item = &'a T;

[src]

`impl<T> IntoIterator for LinkedList<T>`[src]

`type Item = T`

The type of the elements being iterated over.

`type IntoIter = IntoIter<T>`

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>ⓘNotable traits for IntoIter<T>
impl<T> Iterator for IntoIter<T>
    type Item = T;

[src]

Consumes the list into an iterator yielding elements by value.

`impl<'a, T> IntoIterator for &'a mut LinkedList<T>`[src]

`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) -> IterMut<'a, T>ⓘNotable traits for IterMut<'a, T>
impl<'a, T> Iterator for IterMut<'a, T>
    type Item = &'a mut T;

[src]

`impl<T> Ord for LinkedList<T> where T: Ord,` [src]

`fn cmp(&self, other: &LinkedList<T>) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where T: PartialEq<T>,` [src]

`fn eq(&self, other: &LinkedList<T>) -> bool`[src]

`fn ne(&self, other: &LinkedList<T>) -> bool`[src]

`impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where T: PartialOrd<T>,` [src]

`fn partial_cmp(&self, other: &LinkedList<T>) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<T> Send for LinkedList<T> where T: Send,` [src]

`impl<T> Sync for LinkedList<T> where T: Sync,` [src]

Auto Trait Implementations

`impl<T> RefUnwindSafe for LinkedList<T> where T: RefUnwindSafe,`

`impl<T> Unpin for LinkedList<T>`

`impl<T> UnwindSafe for LinkedList<T> where T: RefUnwindSafe + UnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

fn borrow(&self) -> &TⓘNotable 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 R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

fn borrow_mut(&mut self) -> &mut TⓘNotable 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 R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl IntoIterator for I where I: Iterator,` [src]

`type Item = ::Item`

The type of the elements being iterated over.

`type IntoIter = I`

Which kind of iterator are we turning this into?

`fn into_iter(self) -> I`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/collections/struct.LinkedList.html

Struct std::collections::LinkedList

Implementations

impl<T> LinkedList<T>[src]

pub const fn new() -> LinkedList<T>[src]

Examples

pub fn append(&mut self, other: &mut LinkedList<T>)[src]

Examples

pub fn prepend(&mut self, other: &mut LinkedList<T>)[src]

pub fn iter(&self) -> Iter<'_, T>ⓘNotable traits for Iter<'a, T> impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T; [src]

Notable traits for Iter<'a, T>

Examples

pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘNotable traits for IterMut<'a, T> impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut T; [src]

Notable traits for IterMut<'a, T>

Examples

pub fn cursor_front(&self) -> Cursor<'_, T>[src]

pub fn cursor_front_mut(&mut self) -> CursorMut<'_, T>[src]

pub fn cursor_back(&self) -> Cursor<'_, T>[src]

pub fn cursor_back_mut(&mut self) -> CursorMut<'_, T>[src]

pub fn is_empty(&self) -> bool[src]

Examples

pub fn len(&self) -> usize[src]

Examples

pub fn clear(&mut self)[src]

Examples

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

Examples

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

Examples

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

Examples

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

Examples

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

Examples

pub fn push_front(&mut self, elt: T)[src]

Examples

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

Examples

pub fn push_back(&mut self, elt: T)[src]

Examples

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

Examples

pub fn split_off(&mut self, at: usize) -> LinkedList<T>[src]

Panics

Examples

pub fn remove(&mut self, at: usize) -> T[src]

Panics

Examples

pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F>ⓘNotable traits for DrainFilter<'_, T, F> impl<'_, T, F> Iterator for DrainFilter<'_, T, F> where F: FnMut(&mut T) -> bool, type Item = T; where F: FnMut(&mut T) -> bool, [src]

Notable traits for DrainFilter<'_, T, F>

Examples

Trait Implementations

impl<T> Clone for LinkedList<T> where T: Clone, [src]

fn clone(&self) -> LinkedList<T>[src]

fn clone_from(&mut self, other: &LinkedList<T>)[src]

impl<T> Debug for LinkedList<T> where T: Debug, [src]

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

impl<T> Default for LinkedList<T>[src]

fn default() -> LinkedList<T>[src]

impl<T> Drop for LinkedList<T>[src]

fn drop(&mut self)[src]

impl<T> Eq for LinkedList<T> where T: Eq, [src]

impl<'a, T> Extend<&'a T> for LinkedList<T> where T: 'a + Copy, [src]1.2.0

fn extend<I>(&mut self, iter: I) where I: IntoIterator<Item = &'a T>, [src]

fn extend_one(&mut self, &'a T)[src]

fn extend_reserve(&mut self, additional: usize)[src]

impl<T> Extend<T> for LinkedList<T>[src]

fn extend<I>(&mut self, iter: I) where I: IntoIterator<Item = T>, [src]

fn extend_one(&mut self, elem: T)[src]

fn extend_reserve(&mut self, additional: usize)[src]

impl<T> FromIterator<T> for LinkedList<T>[src]

fn from_iter<I>(iter: I) -> LinkedList<T> where I: IntoIterator<Item = T>, [src]

impl<T> Hash for LinkedList<T> where T: Hash, [src]

fn hash<H>(&self, state: &mut H) where H: Hasher, [src]

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

impl<'a, T> IntoIterator for &'a LinkedList<T>[src]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>ⓘNotable traits for Iter<'a, T> impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T; [src]

Notable traits for Iter<'a, T>

`impl<T> LinkedList<T>`[src]

`pub const fn new() -> LinkedList<T>`[src]

`pub fn append(&mut self, other: &mut LinkedList<T>)`[src]

`pub fn prepend(&mut self, other: &mut LinkedList<T>)`[src]

`pub fn iter(&self) -> Iter<'_, T>ⓘNotable traits for Iter<'a, T> impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`[src]

`pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘNotable traits for IterMut<'a, T> impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut T;`[src]

`pub fn cursor_front(&self) -> Cursor<'_, T>`[src]

`pub fn cursor_front_mut(&mut self) -> CursorMut<'_, T>`[src]

`pub fn cursor_back(&self) -> Cursor<'_, T>`[src]

`pub fn cursor_back_mut(&mut self) -> CursorMut<'_, T>`[src]

`pub fn is_empty(&self) -> bool`[src]

`pub fn len(&self) -> usize`[src]

`pub fn clear(&mut self)`[src]

`pub fn contains(&self, x: &T) -> bool where T: PartialEq<T>,` [src]1.12.0

`pub fn front(&self) -> Option<&T>`[src]

`pub fn front_mut(&mut self) -> Option<&mut T>`[src]

`pub fn back(&self) -> Option<&T>`[src]

`pub fn back_mut(&mut self) -> Option<&mut T>`[src]

`pub fn push_front(&mut self, elt: T)`[src]

`pub fn pop_front(&mut self) -> Option<T>`[src]

`pub fn push_back(&mut self, elt: T)`[src]

`pub fn pop_back(&mut self) -> Option<T>`[src]

`pub fn split_off(&mut self, at: usize) -> LinkedList<T>`[src]

`pub fn remove(&mut self, at: usize) -> T`[src]

`pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F>ⓘNotable traits for DrainFilter<'_, T, F> impl<'_, T, F> Iterator for DrainFilter<'_, T, F> where F: FnMut(&mut T) -> bool, type Item = T; where F: FnMut(&mut T) -> bool,` [src]

`impl<T> Clone for LinkedList<T> where T: Clone,` [src]

`fn clone(&self) -> LinkedList<T>`[src]

`fn clone_from(&mut self, other: &LinkedList<T>)`[src]

`impl<T> Debug for LinkedList<T> where T: Debug,` [src]

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<T> Default for LinkedList<T>`[src]

`fn default() -> LinkedList<T>`[src]

`impl<T> Drop for LinkedList<T>`[src]

`fn drop(&mut self)`[src]

`impl<T> Eq for LinkedList<T> where T: Eq,` [src]

`impl<'a, T> Extend<&'a T> for LinkedList<T> where T: 'a + Copy,` [src]1.2.0

`fn extend<I>(&mut self, iter: I) where I: IntoIterator<Item = &'a T>,` [src]

`fn extend_one(&mut self, &'a T)`[src]

`fn extend_reserve(&mut self, additional: usize)`[src]

`impl<T> Extend<T> for LinkedList<T>`[src]

`fn extend<I>(&mut self, iter: I) where I: IntoIterator<Item = T>,` [src]

`fn extend_one(&mut self, elem: T)`[src]

`fn extend_reserve(&mut self, additional: usize)`[src]

`impl<T> FromIterator<T> for LinkedList<T>`[src]

`fn from_iter<I>(iter: I) -> LinkedList<T> where I: IntoIterator<Item = T>,` [src]

`impl<T> Hash for LinkedList<T> where T: Hash,` [src]

`fn hash<H>(&self, state: &mut H) where H: Hasher,` [src]

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

`impl<'a, T> IntoIterator for &'a LinkedList<T>`[src]

`type Item = &'a T`

`type IntoIter = Iter<'a, T>`

`fn into_iter(self) -> Iter<'a, T>ⓘNotable traits for Iter<'a, T> impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`[src]

`impl<T> IntoIterator for LinkedList<T>`[src]

`type Item = T`

`type IntoIter = IntoIter<T>`

`fn into_iter(self) -> IntoIter<T>ⓘNotable traits for IntoIter<T> impl<T> Iterator for IntoIter<T> type Item = T;`[src]

`impl<'a, T> IntoIterator for &'a mut LinkedList<T>`[src]

`type Item = &'a mut T`

`type IntoIter = IterMut<'a, T>`

`fn into_iter(self) -> IterMut<'a, T>ⓘNotable traits for IterMut<'a, T> impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut T;`[src]

`impl<T> Ord for LinkedList<T> where T: Ord,` [src]

`fn cmp(&self, other: &LinkedList<T>) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where T: PartialEq<T>,` [src]

`fn eq(&self, other: &LinkedList<T>) -> bool`[src]

`fn ne(&self, other: &LinkedList<T>) -> bool`[src]

`impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where T: PartialOrd<T>,` [src]

`fn partial_cmp(&self, other: &LinkedList<T>) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<T> Send for LinkedList<T> where T: Send,` [src]

`impl<T> Sync for LinkedList<T> where T: Sync,` [src]

`impl<T> RefUnwindSafe for LinkedList<T> where T: RefUnwindSafe,`

`impl<T> Unpin for LinkedList<T>`

`impl<T> UnwindSafe for LinkedList<T> where T: RefUnwindSafe + UnwindSafe,`

`impl<T> Any for T where T: 'static + ?Sized,` [src]