Struct nom::lib::std::collections::linked_list::LinkedList 1.0.0[−][src]
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>
1.0.0 (const: 1.32.0)[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]
linked_list_prepend
)Moves all elements from other
to the begin of the list.
pub fn iter(&self) -> Iter<'_, 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>ⓘ
[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]
linked_list_cursors
)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]
linked_list_cursors
)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]
linked_list_cursors
)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]
linked_list_cursors
)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>,
1.12.0[src]
T: PartialEq<T>,
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]
linked_list_remove
)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]
Notable traits for DrainFilter<'_, T, F>
impl<'_, T, F> Iterator for DrainFilter<'_, T, F> where
F: FnMut(&mut T) -> bool, type Item = T;
F: FnMut(&mut T) -> bool,
🔬 This is a nightly-only experimental API. (drain_filter
)
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]
T: Clone,
pub fn clone(&self) -> LinkedList<T>
[src]
pub fn clone_from(&mut self, other: &LinkedList<T>)
[src]
impl<T> Debug for LinkedList<T> where
T: Debug,
[src]
T: Debug,
impl<T> Default for LinkedList<T>
[src]
pub fn default() -> LinkedList<T>
[src]
Creates an empty LinkedList<T>
.
impl<T> Drop for LinkedList<T>
[src]
impl<T> Eq for LinkedList<T> where
T: Eq,
[src]
T: Eq,
impl<'a, T> Extend<&'a T> for LinkedList<T> where
T: 'a + Copy,
1.2.0[src]
T: 'a + Copy,
pub fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = &'a T>,
[src]
I: IntoIterator<Item = &'a T>,
pub fn extend_one(&mut self, &'a T)
[src]
pub fn extend_reserve(&mut self, additional: usize)
[src]
impl<T> Extend<T> for LinkedList<T>
[src]
pub fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
pub fn extend_one(&mut self, elem: T)
[src]
pub fn extend_reserve(&mut self, additional: usize)
[src]
impl<T> FromIterator<T> for LinkedList<T>
[src]
pub fn from_iter<I>(iter: I) -> LinkedList<T> where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<T> Hash for LinkedList<T> where
T: Hash,
[src]
T: Hash,
pub fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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?
pub fn into_iter(self) -> IterMut<'a, T>ⓘ
[src]
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?
pub fn into_iter(self) -> Iter<'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?
pub fn into_iter(self) -> IntoIter<T>ⓘ
[src]
Consumes the list into an iterator yielding elements by value.
impl<T> Ord for LinkedList<T> where
T: Ord,
[src]
T: Ord,
pub fn cmp(&self, other: &LinkedList<T>) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
pub fn eq(&self, other: &LinkedList<T>) -> bool
[src]
pub fn ne(&self, other: &LinkedList<T>) -> bool
[src]
impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
pub fn partial_cmp(&self, other: &LinkedList<T>) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<T> Send for LinkedList<T> where
T: Send,
[src]
T: Send,
impl<T> Sync for LinkedList<T> where
T: Sync,
[src]
T: Sync,
Auto Trait Implementations
impl<T> RefUnwindSafe for LinkedList<T> where
T: RefUnwindSafe,
[src]
T: RefUnwindSafe,
impl<T> Unpin for LinkedList<T>
[src]
impl<T> UnwindSafe for LinkedList<T> where
T: RefUnwindSafe + UnwindSafe,
[src]
T: RefUnwindSafe + UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut Tⓘ
[src]
impl<T> Conv for T
impl<T> Conv for T
impl<T> FmtForward for T
pub fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Self: Binary,
pub fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Self: Display,
pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Self: LowerExp,
pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Self: LowerHex,
pub fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Self: Octal,
pub fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Self: Pointer,
pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Self: UpperExp,
pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Self: UpperHex,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pipe for T where
T: ?Sized,
T: ?Sized,
pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_ref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_as_mut<'a, U, R>(
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
pub fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
impl<T> Pipe for T
impl<T> PipeAsRef for T
pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Self: AsRef<T>,
T: 'a,
R: 'a,
pub fn pipe_as_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
impl<T> PipeBorrow for T
pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Self: Borrow<T>,
T: 'a,
R: 'a,
pub fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
impl<T> PipeDeref for T
pub fn pipe_deref<'a, R>(
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
pub fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
impl<T> PipeRef for T
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
R: 'a,
impl<T> Tap for T
pub fn tap(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
impl<T> Tap for T
pub fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
impl<T> TapDeref for T
pub fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> TryConv for T
impl<T> TryConv for T
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,