Struct thingbuf::mpsc::blocking::StaticReceiver
source · pub struct StaticReceiver<T: 'static, R: 'static = DefaultRecycle> { /* private fields */ }
std
and static
only.Expand description
Synchronously receives values from associated StaticSender
s.
Instances of this struct are created by the StaticChannel::split
and
``StaticChannel::try_split` functions.
Implementations§
source§impl<T, R> StaticReceiver<T, R>
impl<T, R> StaticReceiver<T, R>
sourcepub fn recv_ref(&self) -> Option<RecvRef<'_, T>>
pub fn recv_ref(&self) -> Option<RecvRef<'_, T>>
Receives the next message for this receiver, by reference.
This method returns None
if the channel has been closed and there are
no remaining messages in the channel’s buffer. This indicates that no
further values can ever be received from this StaticReceiver
. The channel is
closed when all StaticSender
s have been dropped.
If there are no messages in the channel’s buffer, but the channel has not yet been closed, this method will block until a message is sent or the channel is closed.
This method returns a RecvRef
that can be used to read from (or
mutate) the received message by reference. When the RecvRef
is
dropped, the receive operation completes and the slot occupied by
the received message becomes usable for a future send_ref
operation.
If all StaticSender
s for this channel write to the channel’s
slots in place by using the send_ref
or try_send_ref
methods, this method allows messages that own heap allocations to be reused in
place.
Examples
use thingbuf::mpsc::blocking::StaticChannel;
use std::{thread, fmt::Write};
static CHANNEL: StaticChannel<String, 100> = StaticChannel::new();
let (tx, rx) = CHANNEL.split();
thread::spawn(move || {
let mut value = tx.send_ref().unwrap();
write!(value, "hello world!")
.expect("writing to a `String` should never fail");
});
assert_eq!(Some("hello world!"), rx.recv_ref().as_deref().map(String::as_str));
assert_eq!(None, rx.recv().as_deref());
Values are buffered:
use thingbuf::mpsc::blocking::StaticChannel;
use std::fmt::Write;
static CHANNEL: StaticChannel<String, 100> = StaticChannel::new();
let (tx, rx) = CHANNEL.split();
write!(tx.send_ref().unwrap(), "hello").unwrap();
write!(tx.send_ref().unwrap(), "world").unwrap();
assert_eq!("hello", rx.recv_ref().unwrap().as_str());
assert_eq!("world", rx.recv_ref().unwrap().as_str());
sourcepub fn recv(&self) -> Option<T>where
R: Recycle<T>,
pub fn recv(&self) -> Option<T>where R: Recycle<T>,
Receives the next message for this receiver, by value.
This method returns None
if the channel has been closed and there are
no remaining messages in the channel’s buffer. This indicates that no
further values can ever be received from this StaticReceiver
. The channel is
closed when all StaticSender
s have been dropped.
If there are no messages in the channel’s buffer, but the channel has not yet been closed, this method will block until a message is sent or the channel is closed.
When a message is received, it is moved out of the channel by value,
and replaced with a new slot according to the configured recycling
policy. If all StaticSender
s for this channel write to the channel’s
slots in place by using the send_ref
or try_send_ref
methods,
consider using the recv_ref
method instead, to enable the
reuse of heap allocations.
Examples
use thingbuf::mpsc::blocking::StaticChannel;
use std::thread;
static CHANNEL: StaticChannel<i32, 100> = StaticChannel::new();
let (tx, rx) = CHANNEL.split();
thread::spawn(move || {
tx.send(1).unwrap();
});
assert_eq!(Some(1), rx.recv());
assert_eq!(None, rx.recv());
Values are buffered:
use thingbuf::mpsc::blocking::StaticChannel;
static CHANNEL: StaticChannel<i32, 100> = StaticChannel::new();
let (tx, rx) = CHANNEL.split();
tx.send(1).unwrap();
tx.send(2).unwrap();
assert_eq!(Some(1), rx.recv());
assert_eq!(Some(2), rx.recv());
sourcepub fn recv_ref_timeout(
&self,
timeout: Duration
) -> Result<RecvRef<'_, T>, RecvTimeoutError>
Available on non-loom
only.
pub fn recv_ref_timeout( &self, timeout: Duration ) -> Result<RecvRef<'_, T>, RecvTimeoutError>
loom
only.Receives the next message for this receiver, by reference, waiting for at most timeout
.
If there are no messages in the channel’s buffer, but the channel has
not yet been closed, this method will block until a message is sent,
the channel is closed, or the provided timeout
has elapsed.
Returns
Ok
(
RecvRef
<T>)
if a message was received.Err
(
RecvTimeoutError::Timeout
)
if the timeout has elapsed.Err
(
RecvTimeoutError::Closed
)
if the channel has closed.
Examples
use thingbuf::mpsc::{blocking::StaticChannel, errors::RecvTimeoutError};
use std::{thread, fmt::Write, time::Duration};
static CHANNEL: StaticChannel<String, 100> = StaticChannel::new();
let (tx, rx) = CHANNEL.split();
thread::spawn(move || {
thread::sleep(Duration::from_millis(600));
let mut value = tx.send_ref().unwrap();
write!(value, "hello world!")
.expect("writing to a `String` should never fail");
});
assert_eq!(
Err(&RecvTimeoutError::Timeout),
rx.recv_ref_timeout(Duration::from_millis(400)).as_deref().map(String::as_str)
);
assert_eq!(
Ok("hello world!"),
rx.recv_ref_timeout(Duration::from_millis(400)).as_deref().map(String::as_str)
);
assert_eq!(
Err(&RecvTimeoutError::Closed),
rx.recv_ref_timeout(Duration::from_millis(400)).as_deref().map(String::as_str)
);
sourcepub fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError>where
R: Recycle<T>,
Available on non-loom
only.
pub fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError>where R: Recycle<T>,
loom
only.Receives the next message for this receiver, by value, waiting for at most timeout
.
If there are no messages in the channel’s buffer, but the channel
has not yet been closed, this method will block until a message is
sent, the channel is closed, or the provided timeout
has elapsed.
When a message is received, it is moved out of the channel by value,
and replaced with a new slot according to the configured recycling
policy. If all StaticSender
s for this channel write to the
channel’s slots in place by using the send_ref
or
try_send_ref
methods, consider using the recv_ref_timeout
method instead, to enable the reuse of heap allocations.
Returns
Ok
(<T>)
if a message was received.Err
(
RecvTimeoutError::Timeout
)
if the timeout has elapsed.Err
(
RecvTimeoutError::Closed
)
if the channel has closed.
Examples
use thingbuf::mpsc::{blocking::StaticChannel, errors::RecvTimeoutError};
use std::{thread, time::Duration};
static CHANNEL: StaticChannel<i32, 100> = StaticChannel::new();
let (tx, rx) = CHANNEL.split();
thread::spawn(move || {
thread::sleep(Duration::from_millis(600));
tx.send(1).unwrap();
});
assert_eq!(
Err(RecvTimeoutError::Timeout),
rx.recv_timeout(Duration::from_millis(400))
);
assert_eq!(
Ok(1),
rx.recv_timeout(Duration::from_millis(400))
);
assert_eq!(
Err(RecvTimeoutError::Closed),
rx.recv_timeout(Duration::from_millis(400))
);
sourcepub fn try_recv_ref(&self) -> Result<RecvRef<'_, T>, TryRecvError>where
R: Recycle<T>,
pub fn try_recv_ref(&self) -> Result<RecvRef<'_, T>, TryRecvError>where R: Recycle<T>,
Attempts to receive the next message for this receiver by reference without blocking.
This method differs from recv_ref
by returning immediately if the
channel is empty or closed.
Errors
This method returns an error when the channel is closed or there are no remaining messages in the channel’s buffer.
Examples
use thingbuf::mpsc::{blocking, errors::TryRecvError};
let (tx, rx) = blocking::channel(100);
assert!(matches!(rx.try_recv_ref(), Err(TryRecvError::Empty)));
tx.send(1).unwrap();
drop(tx);
assert_eq!(*rx.try_recv_ref().unwrap(), 1);
assert!(matches!(rx.try_recv_ref(), Err(TryRecvError::Closed)));
sourcepub fn try_recv(&self) -> Result<T, TryRecvError>where
R: Recycle<T>,
pub fn try_recv(&self) -> Result<T, TryRecvError>where R: Recycle<T>,
Attempts to receive the next message for this receiver by value without blocking.
This method differs from recv
by returning immediately if the
channel is empty or closed.
Errors
This method returns an error when the channel is closed or there are no remaining messages in the channel’s buffer.
Examples
use thingbuf::mpsc::{blocking, errors::TryRecvError};
let (tx, rx) = blocking::channel(100);
assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));
tx.send(1).unwrap();
drop(tx);
assert_eq!(rx.try_recv().unwrap(), 1);
assert_eq!(rx.try_recv(), Err(TryRecvError::Closed));
sourcepub fn is_closed(&self) -> bool
pub fn is_closed(&self) -> bool
Returns true
if the channel has closed (all corresponding
StaticSender
s have been dropped).
If this method returns true
, no new messages will become available
on this channel. Previously sent messages may still be available.
Trait Implementations§
source§impl<T, R: Debug> Debug for StaticReceiver<T, R>
impl<T, R: Debug> Debug for StaticReceiver<T, R>
source§impl<T, R> Drop for StaticReceiver<T, R>
impl<T, R> Drop for StaticReceiver<T, R>
source§impl<'a, T, R> Iterator for &'a StaticReceiver<T, R>
impl<'a, T, R> Iterator for &'a StaticReceiver<T, R>
source§fn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>( &mut self ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where Self: Sized,
iter_next_chunk
)N
values. Read more1.0.0 · source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
iter_advance_by
)n
elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
n
th element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where Self: Sized, U: IntoIterator<Item = Self::Item>,
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where Self: Sized, U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
Self: Sized,
G: FnMut() -> Self::Item,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where Self: Sized, G: FnMut() -> Self::Item,
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F>where Self: Sized, F: FnMut(Self::Item) -> B,
1.21.0 · source§fn for_each<F>(self, f: F)where
Self: Sized,
F: FnMut(Self::Item),
fn for_each<F>(self, f: F)where Self: Sized, F: FnMut(Self::Item),
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where Self: Sized, F: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where Self: Sized, P: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where Self: Sized,
n
elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where Self: Sized,
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,
1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where Self: Sized, F: FnMut(&Self::Item),
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,
1.0.0 · source§fn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
Self: Sized,
fn collect<B>(self) -> Bwhere B: FromIterator<Self::Item>, Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
Self: Sized,
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere E: Extend<Self::Item>, Self: Sized,
iter_collect_into
)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B)where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,
source§fn is_partitioned<P>(self, predicate: P) -> boolwhere
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> boolwhere Self: Sized, P: FnMut(Self::Item) -> bool,
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> Bwhere
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn fold<B, F>(self, init: B, f: F) -> Bwhere Self: Sized, F: FnMut(B, Self::Item) -> B,
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item>where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere Self: Sized, F: FnMut(Self::Item, Self::Item) -> R, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce
)1.0.0 · source§fn all<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn any<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B>where Self: Sized, F: FnMut(Self::Item) -> Option<B>,
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere Self: Sized, F: FnMut(&Self::Item) -> R, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,
try_find
)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize>where Self: Sized, P: FnMut(Self::Item) -> bool,
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Sized + Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,
1.0.0 · source§fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Sized + Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,
1.0.0 · source§fn cycle(self) -> Cycle<Self>where
Self: Sized + Clone,
fn cycle(self) -> Cycle<Self>where Self: Sized + Clone,
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where Self: Sized,
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · source§fn sum<S>(self) -> Swhere
Self: Sized,
S: Sum<Self::Item>,
fn sum<S>(self) -> Swhere Self: Sized, S: Sum<Self::Item>,
1.11.0 · source§fn product<P>(self) -> Pwhere
Self: Sized,
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere Self: Sized, P: Product<Self::Item>,
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
PartialOrd
elements of
this Iterator
with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn eq<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,
source§fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by
)1.5.0 · source§fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn ne<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,
1.5.0 · source§fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn le<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn gt<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn ge<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> boolwhere
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> boolwhere Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
)source§fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd<K>,
is_sorted
)