Struct naan::impls::result::hkt::ResultOk

pub struct ResultOk<E>(_);

core::result::Result lifted to an HKT1 with the error type pinned to some E.

(Kind Type -> Type)

Trait Implementations

impl<A, E> Alt<ResultOk<E>, A> for Result<A, E>

fn alt(self, b: Self) -> Self

See Alt

impl<A, E> Applicative<ResultOk<E>, A> for Result<A, E>

fn pure(a: A) -> Result<A, E>

Lift A to F<A>

impl<AB, E> Apply<ResultOk<E>, AB> for Result<AB, E>

fn apply_with<A, B, Cloner>( self, a: <ResultOk<E> as HKT1>::T<A>, _: Cloner ) -> <ResultOk<E> as HKT1>::T<B>where AB: F1<A, Ret = B>, Cloner: for<'a> F1<&'a A, Ret = A>,

Apply the function A -> B contained in Self (F<A -> B>) to an instance of F<A> to get F<B>.

fn apply<A, B>(self, a: F::T<A>) -> F::T<B>where Self: Sized, AB: F1<A, Ret = B>, A: Clone,

See [Apply.apply_with]

impl<AB, E> ApplyOnce<ResultOk<E>, AB> for Result<AB, E>

fn apply1<A, B>(self, a: Result<A, E>) -> Result<B, E>where AB: F1Once<A, Ret = B>,

See ApplyOnce

impl<A, E> Foldable<ResultOk<E>, A> for Result<A, E>

fn foldl<B, BAB>(self, f: BAB, b: B) -> Bwhere BAB: F2<B, A, Ret = B>,

Fold the data structure from left -> right

fn foldr<B, ABB>(self, f: ABB, b: B) -> Bwhere ABB: F2<A, B, Ret = B>,

Fold the data structure from right -> left

fn foldl_ref<'a, B, BAB>(&'a self, f: BAB, b: B) -> Bwhere BAB: F2<B, &'a A, Ret = B>, A: 'a,

Fold the data structure from left -> right

fn foldr_ref<'a, B, ABB>(&'a self, f: ABB, b: B) -> Bwhere ABB: F2<&'a A, B, Ret = B>, A: 'a,

Fold the data structure from right -> left

fn fold_map<AB, B>(self, f: AB) -> Bwhere Self: Sized, AB: F1<A, Ret = B>, B: Monoid,

Fold the data structure, accumulating the values into a Monoid.

fn contains<'a>(&'a self, a: &'a A) -> boolwhere &'a A: PartialEq, A: 'a,

Test if the structure contains a value a

fn not_contains<'a>(&'a self, a: &'a A) -> boolwhere &'a A: PartialEq, A: 'a,

Test if the structure does not contain a value a

fn any<'a, P>(&'a self, f: P) -> boolwhere P: F1<&'a A, Ret = bool>, A: 'a,

Test if any element in the structure satisfies a predicate f

fn all<'a, P>(&'a self, f: P) -> boolwhere P: F1<&'a A, Ret = bool>, A: 'a,

Test if every element in the structure satisfies a predicate f

fn length(&self) -> usize

Get the number of elements contained within the structure

fn is_empty(&self) -> bool

Test if the structure is empty

fn find_map<AB, B>(self, f: AB) -> Option<B>where Self: Sized, AB: F1<A, Ret = Option<B>>,

Fold values until a match is found

fn find<P>(self, f: P) -> Option<A>where Self: Sized, P: for<'a> F1<&'a A, Ret = bool>,

Fold values until a match is found

impl<A, E> FoldableOnce<ResultOk<E>, A> for Result<A, E>

fn fold1<B, BAB>(self, f: BAB, b: B) -> Bwhere BAB: F2Once<B, A, Ret = B>,

Fold the data structure

fn fold1_ref<'a, B, BAB>(&'a self, f: BAB, b: B) -> Bwhere BAB: F2Once<B, &'a A, Ret = B>, A: 'a,

Fold the data structure

fn get_or(self, a: A) -> Awhere Self: Sized,

Unwrap the data structure, using a provided default value if empty

impl<A, E> Functor<ResultOk<E>, A> for Result<A, E>

fn fmap<AB, B>(self, f: AB) -> <ResultOk<E> as HKT1>::T<B>where AB: F1<A, Ret = B>,

Use a function from A -> B to transform an F<A> to an F<B>.

impl<A, E> FunctorOnce<ResultOk<E>, A> for Result<A, E>

fn fmap1<AB, B>(self, f: AB) -> Result<B, E>where AB: F1Once<A, Ret = B>,

See FunctorOnce

impl<E> HKT1 for ResultOk<E>

type T<A> = Result<A, E>

The generic type

impl<A, E> Monad<ResultOk<E>, A> for Result<A, E>

fn bind<B, AMB>(self, f: AMB) -> <ResultOk<E> as HKT1>::T<B>where AMB: F1<A, Ret = <ResultOk<E> as HKT1>::T<B>>,

See Monad

fn flatten<AA>(self) -> M::T<AA>where Self: Sized, M: HKT1<T<AA> = A> + HKT1<T<<M as HKT1>::T<AA>> = Self>,

Flatten a nested Monad

impl<A, E> MonadOnce<ResultOk<E>, A> for Result<A, E>

fn bind1<B, AMB>(self, f: AMB) -> Result<B, E>where AMB: F1Once<A, Ret = Result<B, E>>,

See MonadOnce

fn discard<AMB, B>(self, f: AMB) -> M::T<A>where Self: Sized, B: Discard, AMB: for<'a> F1Once<&'a A, Ret = M::T<B>>, M::T<B>: MonadOnce<M, B>,

MonadOnce::bind1 that Discards the output of the function.

fn discard_mut<AMB, B>(self, f: AMB) -> M::T<A>where Self: Sized, B: Discard, AMB: for<'a> F1Once<&'a mut A, Ret = M::T<B>>, M::T<B>: MonadOnce<M, B>,

MonadOnce::discard with mutable access to the data

impl<A, B, E> Traversable<ResultOk<E>, A, B, ()> for Result<A, E>

fn traversem1<Ap, AtoApOfB>( self, f: AtoApOfB ) -> Ap::T<<ResultOk<E> as HKT1>::T<B>>where Ap: HKT1, Ap::T<B>: Applicative<Ap, B> + ApplyOnce<Ap, B>, Ap::T<()>: Applicative<Ap, ()> + ApplyOnce<Ap, ()>, Ap::T<<ResultOk<E> as HKT1>::T<B>>: Applicative<Ap, <ResultOk<E> as HKT1>::T<B>> + ApplyOnce<Ap, <ResultOk<E> as HKT1>::T<B>>, AtoApOfB: F1<A, Ret = Ap::T<B>>,

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

fn traversemm<Ap, AtoApOfB>( self, f: AtoApOfB ) -> Ap::T<<ResultOk<E> as HKT1>::T<B>>where Ap: HKT1, Ap::T<B>: Applicative<Ap, B>, Ap::T<()>: Applicative<Ap, ()>, Ap::T<<ResultOk<E> as HKT1>::T<B>>: Applicative<Ap, <ResultOk<E> as HKT1>::T<B>>, AtoApOfB: F1<A, Ret = Ap::T<B>>,

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

fn traverse<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<F::T<B>>where Ap: HKT1, Self: Sized + Foldable<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: F1<A, Ret = Ap::T<B>>, F: HKT1<T<A> = Self>,

Aliases Traversable::traversem1

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>>,

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

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>>,

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

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