Trait IterTraversableExt 

pub trait IterTraversableExt<This>
where
    This: Iterator,
{
    // Required methods
    fn traverse<F, T, R, E>(self, f: F) -> Result<Vec<R>, E>
       where This: Iterator<Item = T>,
             F: FnMut(T) -> Result<R, E>;
    fn traverse_opt<F, T, R, E>(self, f: F) -> Result<Vec<R>, E>
       where This: Iterator<Item = T>,
             F: FnMut(T) -> Result<Option<R>, E>;
    fn traverse_iter<F, T, I, R, E>(self, f: F) -> Result<Vec<R>, E>
       where This: Iterator<Item = T>,
             F: FnMut(T) -> Result<I, E>,
             I: IntoIterator<Item = R>;
    fn sequence<T, E>(self) -> Result<Vec<T>, E>
       where This: Iterator<Item = Result<T, E>>;
    fn sequence_opt<T, E>(self) -> Result<Vec<T>, E>
       where This: Iterator<Item = Result<Option<T>, E>>;
    fn sequence_iter<T, I, E>(self) -> Result<Vec<T>, E>
       where This: Iterator<Item = Result<I, E>>,
             I: IntoIterator<Item = T>;
}

Extends iterators with traversal and sequencing operations.

Required Methods

fn traverse<F, T, R, E>(self, f: F) -> Result<Vec<R>, E>

where This: Iterator<Item = T>, F: FnMut(T) -> Result<R, E>,

Sequencing operation on Iterator type when inner type is Applicative or Monad like Result. See IterTraversableExt::sequence for traverse with identity closure. Defined by Conor McBride (2005) in Haskell2010 base Data.Traversable.

Traversable structures support element-wise sequencing of Applicative effects (thus also Monad effects) to construct new structures of the same shape as the input.

class (Functor t, Foldable t) => Traversable t where
  traverse :: Applicative f => (a -> f b) -> t a -> f (t b)

From this Haskell definition t is Iterator and f is Result.

Examples

use alux_traversable::*;

let r: Result<_, ()> = [1, 2, 3].into_iter().traverse(|x| Ok(x + x));

assert_eq!(r, Ok(vec![2, 4, 6]));

let r: Result<_, ()> = Some(42).into_iter().traverse(|x| Ok(x + x));

assert_eq!(r, Ok(vec![84]));

fn traverse_opt<F, T, R, E>(self, f: F) -> Result<Vec<R>, E>

where This: Iterator<Item = T>, F: FnMut(T) -> Result<Option<R>, E>,

Sequencing operation on Iterator type when inner type is Applicative or Monad like Result. See IterTraversableExt::sequence for traverse with identity closure. Defined by Conor McBride (2005) in Haskell2010 base Data.Traversable.

Traversable structures support element-wise sequencing of Applicative effects (thus also Monad effects) to construct new structures of the same shape as the input.

class (Functor t, Foldable t) => Traversable t where
  traverse :: Applicative f => (a -> f b) -> t a -> f (t b)

From this Haskell definition t is Iterator and f is Result.

Examples

use alux_traversable::*;

let r: Result<_, ()> = [1, 2, 3].into_iter().traverse_iter(|x| Ok(Some(x + x)));

assert_eq!(r, Ok(vec![2, 4, 6]));

let r: Result<_, ()> = Some(42).into_iter().traverse_iter(|x| Ok(Some(x + x)));

assert_eq!(r, Ok(vec![84]));

fn traverse_iter<F, T, I, R, E>(self, f: F) -> Result<Vec<R>, E>

where This: Iterator<Item = T>, F: FnMut(T) -> Result<I, E>, I: IntoIterator<Item = R>,

The same as IterTraversableExt::traverse_opt, but accepts more general result value as Iterator.

NOTE: The end goal is to have general definition like this for traverse/sequence of Traversable interface (API).

Examples

use alux_traversable::*;

let r: Result<_, ()> = [1, 2, 3].into_iter().traverse_iter(|x| Ok(Some(x + x)));

assert_eq!(r, Ok(vec![2, 4, 6]));

let r: Result<_, ()> = [1, 2, 3].into_iter().traverse_iter(|x| Ok(vec![x, x + x]));

assert_eq!(r, Ok(vec![1, 2, 2, 4, 3, 6]));

fn sequence<T, E>(self) -> Result<Vec<T>, E>

where This: Iterator<Item = Result<T, E>>,

Sequencing operation on Iterator type when inner type is Applicative or Monad like Result. See IterTraversableExt::sequence for traverse with identity closure. Defined by Conor McBride (2005) in Haskell2010 base Data.Traversable.

Traversable structures support element-wise sequencing of Applicative effects (thus also Monad effects) to construct new structures of the same shape as the input.

class (Functor t, Foldable t) => Traversable t where
  traverse :: Applicative f => (a -> f b) -> t a -> f (t b)

From this Haskell definition t is Iterator and f is Result.

Examples

use alux_traversable::*;

let r: Result<_, ()> = [Ok(1), Ok(2), Ok(3)].into_iter().sequence();

assert_eq!(r, Ok(vec![1, 2, 3]));

fn sequence_opt<T, E>(self) -> Result<Vec<T>, E>

where This: Iterator<Item = Result<Option<T>, E>>,

Sequencing operation on Iterator type when inner type is Applicative or Monad like Result. See IterTraversableExt::sequence for traverse with identity closure. Defined by Conor McBride (2005) in Haskell2010 base Data.Traversable.

Traversable structures support element-wise sequencing of Applicative effects (thus also Monad effects) to construct new structures of the same shape as the input.

class (Functor t, Foldable t) => Traversable t where
  traverse :: Applicative f => (a -> f b) -> t a -> f (t b)

From this Haskell definition t is Iterator and f is Result.

Examples

use alux_traversable::*;

let r: Result<_, ()> = [Ok(Some(1)), Ok(Some(2)), Ok(None), Ok(Some(3))].into_iter().sequence_opt();

assert_eq!(r, Ok(vec![1, 2, 3]));

fn sequence_iter<T, I, E>(self) -> Result<Vec<T>, E>

where This: Iterator<Item = Result<I, E>>, I: IntoIterator<Item = T>,

The same as IterTraversableExt::sequence_opt, but accepts more general result value as Iterator.

NOTE: The end goal is to have general definition like this for traverse/sequence of Traversable interface (API).

Examples

use alux_traversable::*;

let r: Result<_, ()> = [Ok(Some(1)), Ok(Some(2)), Ok(None), Ok(Some(3))].into_iter().sequence_iter();

assert_eq!(r, Ok(vec![1, 2, 3]));

let r: Result<_, ()> = [Ok(vec![1, 2]), Ok(vec![]), Ok(vec![3])].into_iter().sequence_iter();

assert_eq!(r, Ok(vec![1, 2, 3]));

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<This> IterTraversableExt<This> for This

where This: Iterator,

Extends iterators with traversal and sequencing operations.