Trait naan::traverse::TraversableOnce

pub trait TraversableOnce<F, A, B, TF>: Traversable<F, A, B, TF> {
    // Required methods
    fn traverse11<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<F::T<B>>
       where Ap: HKT1,
             Self: FoldableOnce<F, A>,
             Ap::T<B>: Applicative<Ap, B> + ApplyOnce<Ap, B>,
             Ap::T<TF>: Applicative<Ap, TF> + ApplyOnce<Ap, TF>,
             Ap::T<F::T<B>>: Applicative<Ap, F::T<B>> + ApplyOnce<Ap, F::T<B>>,
             AtoApOfB: F1Once<A, Ret = Ap::T<B>>,
             F: HKT1<T<A> = Self>;
    fn traverse1m<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<F::T<B>>
       where Self: FoldableOnce<F, A>,
             Ap: HKT1,
             Ap::T<B>: Applicative<Ap, B>,
             Ap::T<TF>: Applicative<Ap, TF>,
             Ap::T<F::T<B>>: Applicative<Ap, F::T<B>>,
             AtoApOfB: F1Once<A, Ret = Ap::T<B>>,
             F: HKT1<T<A> = Self>;

    // Provided methods
    fn traverse_swap<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<F::T<B>>
       where Ap: HKT1,
             Self: Sized + FoldableOnce<F, A>,
             Ap::T<B>: Applicative<Ap, B> + ApplyOnce<Ap, B>,
             Ap::T<TF>: Applicative<Ap, TF> + ApplyOnce<Ap, TF>,
             Ap::T<F::T<B>>: Applicative<Ap, F::T<B>> + ApplyOnce<Ap, F::T<B>>,
             AtoApOfB: F1Once<A, Ret = Ap::T<B>>,
             F: HKT1<T<A> = Self> { ... }
    fn traverse_replicate<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<F::T<B>>
       where Ap: HKT1,
             Self: Sized + FoldableOnce<F, A>,
             Ap::T<B>: Applicative<Ap, B>,
             Ap::T<TF>: Applicative<Ap, TF>,
             Ap::T<F::T<B>>: Applicative<Ap, F::T<B>>,
             AtoApOfB: F1Once<A, Ret = Ap::T<B>>,
             F: HKT1<T<A> = Self> { ... }
}

Traversable’s signatures that guarantee the traversal function will only ever be called once.

Required Methods

fn traverse11<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<F::T<B>>where Ap: HKT1, Self: FoldableOnce<F, A>, Ap::T<B>: Applicative<Ap, B> + ApplyOnce<Ap, B>, Ap::T<TF>: Applicative<Ap, TF> + ApplyOnce<Ap, TF>, Ap::T<F::T<B>>: Applicative<Ap, F::T<B>> + ApplyOnce<Ap, F::T<B>>, AtoApOfB: F1Once<A, Ret = Ap::T<B>>, F: HKT1<T<A> = Self>,

Traverse a structure with 0 or 1 elements, collecting into an Applicative of 0 or 1 elements.

use std::fs::File;

use naan::prelude::*;

fn maybe_path() -> Option<&'static str> {
  None
}

let tried_read: std::io::Result<Option<File>> =
  maybe_path().traverse11::<hkt::std::io::Result, _>(File::open);

assert!(matches!(tried_read, Ok(None)))

fn traverse1m<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<F::T<B>>where Self: FoldableOnce<F, A>, Ap: HKT1, Ap::T<B>: Applicative<Ap, B>, Ap::T<TF>: Applicative<Ap, TF>, Ap::T<F::T<B>>: Applicative<Ap, F::T<B>>, AtoApOfB: F1Once<A, Ret = Ap::T<B>>, F: HKT1<T<A> = Self>,

Traverse a structure with 0 or 1 elements, collecting into an Applicative of 0 or more elements.

Provided Methods

fn traverse_swap<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<F::T<B>>where Ap: HKT1, Self: Sized + FoldableOnce<F, A>, Ap::T<B>: Applicative<Ap, B> + ApplyOnce<Ap, B>, Ap::T<TF>: Applicative<Ap, TF> + ApplyOnce<Ap, TF>, Ap::T<F::T<B>>: Applicative<Ap, F::T<B>> + ApplyOnce<Ap, F::T<B>>, AtoApOfB: F1Once<A, Ret = Ap::T<B>>, F: HKT1<T<A> = Self>,

Aliases TraversableOnce::traverse11

fn traverse_replicate<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<F::T<B>>where Ap: HKT1, Self: Sized + FoldableOnce<F, A>, Ap::T<B>: Applicative<Ap, B>, Ap::T<TF>: Applicative<Ap, TF>, Ap::T<F::T<B>>: Applicative<Ap, F::T<B>>, AtoApOfB: F1Once<A, Ret = Ap::T<B>>, F: HKT1<T<A> = Self>,

Aliases TraversableOnce::traverse1m

Implementations on Foreign Types

impl<A, B, E> TraversableOnce<ResultOk<E>, A, B, ()> for Result<A, E>where ResultOk<E>: HKT1<T<B> = Result<B, E>> + HKT1<T<A> = Result<A, E>>,

fn traverse1m<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<Result<B, E>>where Ap: HKT1, Ap::T<B>: Applicative<Ap, B>, Ap::T<Result<B, E>>: Applicative<Ap, Result<B, E>>, AtoApOfB: F1Once<A, Ret = Ap::T<B>>,

fn traverse11<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<Result<B, E>>where Ap: HKT1, Ap::T<B>: Applicative<Ap, B> + ApplyOnce<Ap, B>, Ap::T<()>: Applicative<Ap, ()> + ApplyOnce<Ap, ()>, Ap::T<Result<B, E>>: Applicative<Ap, Result<B, E>> + ApplyOnce<Ap, Result<B, E>>, AtoApOfB: F1Once<A, Ret = Ap::T<B>>,

impl<A, B> TraversableOnce<Option, A, B, ()> for Option<A>

fn traverse1m<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<Option<B>>where Ap: HKT1, Self: FoldableOnce<Option, A>, Ap::T<B>: Applicative<Ap, B>, Ap::T<()>: Applicative<Ap, ()>, Ap::T<Option<B>>: Applicative<Ap, Option<B>>, AtoApOfB: F1Once<A, Ret = Ap::T<B>>, Option: HKT1<T<A> = Self>,

fn traverse11<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<Option<B>>where Ap: HKT1, Ap::T<B>: Applicative<Ap, B> + ApplyOnce<Ap, B>, Ap::T<()>: Applicative<Ap, ()> + ApplyOnce<Ap, ()>, Ap::T<Option<B>>: Applicative<Ap, Option<B>> + ApplyOnce<Ap, Option<B>>, AtoApOfB: F1Once<A, Ret = Ap::T<B>>,

Implementors