in gazebo/src/ext/iter.rs [42:196]
fn try_any<F, E>(self, any: F) -> Result<bool, E>
where
Self: Sized,
F: FnMut(Self::Item) -> Result<bool, E>;
/// Like `all`, except allow the function supplied to return a `Result` type, where we `Err`
/// on the first encounter of `Err`.
///
/// ```
/// use gazebo::prelude::*;
///
/// fn true_if_even_throw_on_zero(x: &usize) -> Result<bool, ()> {
/// if *x == 0 {
/// Err(())
/// } else {
/// Ok(x % 2 == 0)
/// }
/// }
///
/// let x = [2, 4, 2];
/// assert_eq!(x.iter().try_all(true_if_even_throw_on_zero), Ok(true));
///
/// let x = [1, 3, 5];
/// assert_eq!(x.iter().try_all(true_if_even_throw_on_zero), Ok(false));
///
/// let x = [2, 0, 2];
/// assert_eq!(x.iter().try_all(true_if_even_throw_on_zero), Err(()));
///
/// ```
fn try_all<F, E>(self, any: F) -> Result<bool, E>
where
Self: Sized,
F: FnMut(Self::Item) -> Result<bool, E>;
/// Like `eq_by`, except allow the function supplied to return a `Result` type, where we `Err`
/// on the first encounter of `Err`.
///
/// ```
/// use gazebo::prelude::*;
///
/// fn double_eq_throw_on_zero(x: &usize, y: &usize) -> Result<bool, ()> {
/// if *x == 0 || *y == 0 {
/// Err(())
/// } else {
/// Ok(x * 2 == *y)
/// }
/// }
///
/// let x = [1, 4, 2];
/// let y = [2, 8, 4];
///
/// assert_eq!(x.iter().try_eq_by(&y, double_eq_throw_on_zero), Ok(true));
///
/// let x = [1, 4, 2];
/// let y = [2, 0, 4];
///
/// assert_eq!(x.iter().try_eq_by(&y, double_eq_throw_on_zero), Err(()));
/// ```
fn try_eq_by<I, F, E>(self, other: I, eq: F) -> Result<bool, E>
where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Result<bool, E>;
/// Like `cmp_by`, except allow the function supplied to return a `Result` type, where we `Err`
/// on the first encounter of `Err`.
///
/// ```
/// use gazebo::prelude::*;
/// use std::cmp::Ordering;
///
/// fn double_cmp_throw_on_zero(x: &usize, y: &usize) -> Result<Ordering, ()> {
/// if *x == 0 || *y == 0 {
/// Err(())
/// } else {
/// Ok((x * 2).cmp(y))
/// }
/// }
///
/// let x = [1, 4, 2];
/// let y = [2, 8, 4];
///
/// assert_eq!(x.iter().try_cmp_by(&y, double_cmp_throw_on_zero), Ok(Ordering::Equal));
///
/// let x = [1, 2, 2];
/// let y = [2, 8, 4];
///
/// assert_eq!(x.iter().try_cmp_by(&y, double_cmp_throw_on_zero), Ok(Ordering::Less));
///
/// let x = [1, 4];
/// let y = [2, 8, 4];
///
/// assert_eq!(x.iter().try_cmp_by(&y, double_cmp_throw_on_zero), Ok(Ordering::Less));
///
/// let x = [1, 4, 4];
/// let y = [2, 8, 4];
///
/// assert_eq!(x.iter().try_cmp_by(&y, double_cmp_throw_on_zero), Ok(Ordering::Greater));
///
/// let x = [1, 4, 2, 3];
/// let y = [2, 8, 4];
///
/// assert_eq!(x.iter().try_cmp_by(&y, double_cmp_throw_on_zero), Ok(Ordering::Greater));
///
/// let x = [1, 4, 2];
/// let y = [2, 0, 4];
///
/// assert_eq!(x.iter().try_cmp_by(&y, double_cmp_throw_on_zero), Err(()));
/// ```
fn try_cmp_by<I, F, E>(self, other: I, cmp: F) -> Result<Ordering, E>
where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Result<Ordering, E>;
/// Like `unzip`, except allowing the current `Iterator` to contain `Result` type, where we `Err`
/// on the first encounter of `Err`.
///
/// ```
/// use gazebo::prelude::*;
///
/// let i = vec![Ok::<_, ()>((1, "a")), Ok((2, "b"))];
///
/// assert_eq!(i.into_iter().try_unzip(), Ok((vec![1, 2], vec!["a", "b"])));
///
/// let i = vec![Ok((1, "a")), Err(()), Ok((2, "b"))];
///
/// assert_eq!(i.into_iter().try_unzip::<_, _, Vec<_>, Vec<_>, _>(), Err(()));
/// ```
fn try_unzip<A, B, FromA, FromB, E>(self) -> Result<(FromA, FromB), E>
where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = Result<(A, B), E>>;
/// If this iterator contains a single element, return it. Otherwise, return `None`.
///
/// ```
/// use gazebo::prelude::*;
///
/// let i = vec![1];
/// assert_eq!(i.into_iter().into_singleton(), Some(1));
///
/// let i = Vec::<i64>::new();
/// assert_eq!(i.into_iter().into_singleton(), None);
///
/// let i = vec![1, 2];
/// assert_eq!(i.into_iter().into_singleton(), None);
/// ```
fn into_singleton(self) -> Option<Self::Item>
where
Self: Sized;
}
pub trait IterDuped: Sized {