[−][src]Struct tranche::BasedTranche
A based tranche of T
.
Based tranches are just like tranches, with the addition of an offset
method which returns how many items were taken from the front of
the original based tranche returned from BasedTranche::new
.
Methods
impl<'a, T> BasedTranche<'a, T>
[src]
pub fn new(slice: &'a impl AsRef<[T]>) -> Self
[src]
Creates a new based tranche of T
.
Examples
let parisien = BasedTranche::new(&[ "baguette", "jambon", "beurre", ]);
pub fn len(&self) -> usize
[src]
Returns the number of elements in the tranche.
Examples
let a = BasedTranche::new(&[1, 2, 3]); assert_eq!(a.len(), 3);
pub fn is_empty(&self) -> bool
[src]
Returns true
if the tranche has a length of 0.
Examples
let a = BasedTranche::new(&[1, 2, 3]); assert!(!a.is_empty());
pub fn offset(&self) -> usize
[src]
Returns the starting offset of this based tranche.
pub fn take_first(&mut self) -> Result<&'a T, UnexpectedEndError>
[src]
Takes the first element out of the tranche.
Returns the first element of self
, or Err(_)
if it is empty.
Examples
let mut v = BasedTranche::new(&[10, 40, 30]); assert_eq!(v.take_first().unwrap(), &10); assert_eq!(v.as_slice(), &[40, 30]); let mut w = <BasedTranche<i32>>::new(&[]); let err = w.take_first().unwrap_err(); assert_eq!(err.needed(), 1); assert_eq!(err.len(), 0);
pub fn take_front(&mut self, n: usize) -> Result<Self, UnexpectedEndError>
[src]
Takes the first n
elements out of the tranche.
Returns a new tranche with the first n
elements of self
, or
Err(_)
if it is not long enough.
Examples
let mut v = BasedTranche::new(&[10, 40, 30]); assert_eq!(v.take_front(2).unwrap().as_slice(), &[10, 40]); assert_eq!(v.as_slice(), &[30]); let err = v.take_front(3).unwrap_err(); assert_eq!(err.needed(), 3); assert_eq!(err.len(), 1);
pub fn as_slice(&self) -> &'a [T]
[src]
Views the tranche's buffer as a slice.
This has the same lifetime as the original buffer, and so the tranche can continue to be used while this exists.
Examples
let mut tranche = BasedTranche::new(&[1, 2, 3]); assert_eq!(tranche.as_slice(), &[1, 2, 3]); assert!(tranche.take_first().is_ok()); assert_eq!(tranche.as_slice(), &[2, 3]);
pub const fn as_ptr(&self) -> *const T
[src]
Returns a raw pointer to the tranche's buffer.
Examples
let tranche = BasedTranche::new(&[1, 2, 3]); let ptr = tranche.as_ptr();
impl<'a> BasedTranche<'a, u8>
[src]
pub fn take_front_as<T>(
&mut self,
n: usize
) -> Result<Tranche<'a, T>, UnexpectedEndError> where
T: AlwaysAligned + AlwaysValid + Immutable,
[src]
&mut self,
n: usize
) -> Result<Tranche<'a, T>, UnexpectedEndError> where
T: AlwaysAligned + AlwaysValid + Immutable,
impl<'_> BasedTranche<'a, u8>
[src]
pub fn take_u8(&mut self) -> Result<u8, UnexpectedEndError>
[src]
Takes the first u8
out of the tranche.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i8(&mut self) -> Result<i8, UnexpectedEndError>
[src]
Takes the first i8
out of the tranche.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u16_ne(&mut self) -> Result<u16, UnexpectedEndError>
[src]
Returns a
u16
by taking the first
mem::size_of::<u16>()
bytes out of the tranche in
native
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u16_le(&mut self) -> Result<u16, UnexpectedEndError>
[src]
Returns a
u16
by taking the first
mem::size_of::<u16>()
bytes out of the tranche in
little
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u16_be(&mut self) -> Result<u16, UnexpectedEndError>
[src]
Returns a
u16
by taking the first
mem::size_of::<u16>()
bytes out of the tranche in
big
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i16_ne(&mut self) -> Result<i16, UnexpectedEndError>
[src]
Returns a
i16
by taking the first
mem::size_of::<i16>()
bytes out of the tranche in
native
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i16_le(&mut self) -> Result<i16, UnexpectedEndError>
[src]
Returns a
i16
by taking the first
mem::size_of::<i16>()
bytes out of the tranche in
little
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i16_be(&mut self) -> Result<i16, UnexpectedEndError>
[src]
Returns a
i16
by taking the first
mem::size_of::<i16>()
bytes out of the tranche in
big
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u32_ne(&mut self) -> Result<u32, UnexpectedEndError>
[src]
Returns a
u32
by taking the first
mem::size_of::<u32>()
bytes out of the tranche in
native
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u32_le(&mut self) -> Result<u32, UnexpectedEndError>
[src]
Returns a
u32
by taking the first
mem::size_of::<u32>()
bytes out of the tranche in
little
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u32_be(&mut self) -> Result<u32, UnexpectedEndError>
[src]
Returns a
u32
by taking the first
mem::size_of::<u32>()
bytes out of the tranche in
big
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i32_ne(&mut self) -> Result<i32, UnexpectedEndError>
[src]
Returns a
i32
by taking the first
mem::size_of::<i32>()
bytes out of the tranche in
native
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i32_le(&mut self) -> Result<i32, UnexpectedEndError>
[src]
Returns a
i32
by taking the first
mem::size_of::<i32>()
bytes out of the tranche in
little
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i32_be(&mut self) -> Result<i32, UnexpectedEndError>
[src]
Returns a
i32
by taking the first
mem::size_of::<i32>()
bytes out of the tranche in
big
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u64_ne(&mut self) -> Result<u64, UnexpectedEndError>
[src]
Returns a
u64
by taking the first
mem::size_of::<u64>()
bytes out of the tranche in
native
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u64_le(&mut self) -> Result<u64, UnexpectedEndError>
[src]
Returns a
u64
by taking the first
mem::size_of::<u64>()
bytes out of the tranche in
little
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u64_be(&mut self) -> Result<u64, UnexpectedEndError>
[src]
Returns a
u64
by taking the first
mem::size_of::<u64>()
bytes out of the tranche in
big
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i64_ne(&mut self) -> Result<i64, UnexpectedEndError>
[src]
Returns a
i64
by taking the first
mem::size_of::<i64>()
bytes out of the tranche in
native
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i64_le(&mut self) -> Result<i64, UnexpectedEndError>
[src]
Returns a
i64
by taking the first
mem::size_of::<i64>()
bytes out of the tranche in
little
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i64_be(&mut self) -> Result<i64, UnexpectedEndError>
[src]
Returns a
i64
by taking the first
mem::size_of::<i64>()
bytes out of the tranche in
big
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u128_ne(&mut self) -> Result<u128, UnexpectedEndError>
[src]
Returns a
u128
by taking the first
mem::size_of::<u128>()
bytes out of the tranche in
native
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u128_le(&mut self) -> Result<u128, UnexpectedEndError>
[src]
Returns a
u128
by taking the first
mem::size_of::<u128>()
bytes out of the tranche in
little
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_u128_be(&mut self) -> Result<u128, UnexpectedEndError>
[src]
Returns a
u128
by taking the first
mem::size_of::<u128>()
bytes out of the tranche in
big
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i128_ne(&mut self) -> Result<i128, UnexpectedEndError>
[src]
Returns a
i128
by taking the first
mem::size_of::<i128>()
bytes out of the tranche in
native
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i128_le(&mut self) -> Result<i128, UnexpectedEndError>
[src]
Returns a
i128
by taking the first
mem::size_of::<i128>()
bytes out of the tranche in
little
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_i128_be(&mut self) -> Result<i128, UnexpectedEndError>
[src]
Returns a
i128
by taking the first
mem::size_of::<i128>()
bytes out of the tranche in
big
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_usize_ne(&mut self) -> Result<usize, UnexpectedEndError>
[src]
Returns a
usize
by taking the first
mem::size_of::<usize>()
bytes out of the tranche in
native
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_usize_le(&mut self) -> Result<usize, UnexpectedEndError>
[src]
Returns a
usize
by taking the first
mem::size_of::<usize>()
bytes out of the tranche in
little
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_usize_be(&mut self) -> Result<usize, UnexpectedEndError>
[src]
Returns a
usize
by taking the first
mem::size_of::<usize>()
bytes out of the tranche in
big
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_isize_ne(&mut self) -> Result<isize, UnexpectedEndError>
[src]
Returns a
isize
by taking the first
mem::size_of::<isize>()
bytes out of the tranche in
native
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_isize_le(&mut self) -> Result<isize, UnexpectedEndError>
[src]
Returns a
isize
by taking the first
mem::size_of::<isize>()
bytes out of the tranche in
little
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
pub fn take_isize_be(&mut self) -> Result<isize, UnexpectedEndError>
[src]
Returns a
isize
by taking the first
mem::size_of::<isize>()
bytes out of the tranche in
big
endian order.
The internal offset is incremented accordingly.
Returns Err(_)
if self
is not long enough.
Trait Implementations
impl<'_, T> Clone for BasedTranche<'_, T>
[src]
fn clone(&self) -> Self
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<'_, T> Debug for BasedTranche<'_, T> where
T: Debug,
[src]
T: Debug,
impl<'_, T> Default for BasedTranche<'_, T>
[src]
impl<'_, T> ExactSizeIterator for BasedTranche<'_, T>
[src]
impl<'a, T> From<BasedTranche<'a, T>> for Tranche<'a, T>
[src]
fn from(based_tranche: BasedTranche<'a, T>) -> Self
[src]
impl<'a, T> From<Tranche<'a, T>> for BasedTranche<'a, T>
[src]
impl<'_, T> FusedIterator for BasedTranche<'_, T>
[src]
impl<'a, T> Iterator for BasedTranche<'a, T>
[src]
type Item = &'a T
The type of the elements being iterated over.
fn next(&mut self) -> Option<Self::Item>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
fn count(self) -> usize
[src]
fn last(self) -> Option<Self::Item>
1.0.0[src]
fn nth(&mut self, n: usize) -> Option<Self::Item>
1.0.0[src]
fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]
U: IntoIterator,
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
F: FnMut(Self::Item),
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(Self::Item) -> Option<B>,
fn enumerate(self) -> Enumerate<Self>
1.0.0[src]
fn peekable(self) -> Peekable<Self>
1.0.0[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]
P: FnMut(Self::Item) -> Option<B>,
fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]
fn take(self, n: usize) -> Take<Self>
1.0.0[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]
F: FnMut(Self::Item) -> U,
U: IntoIterator,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
Self::Item: IntoIterator,
fn fuse(self) -> Fuse<Self>
1.0.0[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut Self
1.0.0[src]
#[must_use =
"if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
1.0.0[src]
B: FromIterator<Self::Item>,
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
1.0.0[src]
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
[src]
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.0.0[src]
F: FnMut(B, Self::Item) -> B,
fn fold_first<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
fn try_find<F, E, R>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>,
[src]
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
1.0.0[src]
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]
Self: DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
1.0.0[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
fn cycle(self) -> Cycle<Self> where
Self: Clone,
1.0.0[src]
Self: Clone,
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
S: Sum<Self::Item>,
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
impl<'_, T> Send for BasedTranche<'_, T> where
T: Sync,
[src]
T: Sync,
impl<'_, T> Sync for BasedTranche<'_, T> where
T: Sync,
[src]
T: Sync,
Auto Trait Implementations
impl<'a, T> RefUnwindSafe for BasedTranche<'a, T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<'a, T> Unpin for BasedTranche<'a, T>
impl<'a, T> UnwindSafe for BasedTranche<'a, T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
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,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::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]
T: Clone,
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<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
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>,