Trait rust2fun::apply::Apply

pub trait Apply<B>: Functor<B> + Semigroupal<B> {
    // Required method
    fn ap<A>(self, fa: Self::Target<A>) -> Self::Target<B>
       where Self::Param: FnOnce(A) -> B;

    // Provided methods
    fn ap2<A, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B) -> Z,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Functor<Z, Target<Z> = Self::Target<Z>>,
             Self: Sized { ... }
    fn ap3<A, C, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>,
        fc: Self::Target<C>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B, C) -> Z,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>,
             Self::Target<(((Self::Param, B), A), C)>: Functor<Z, Target<Z> = Self::Target<Z>>,
             Self: Sized { ... }
    fn ap4<A, C, D, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B, C, D) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>,
             Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>,
             Self::Target<((((Self::Param, B), A), C), D)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn ap5<A, C, D, E, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B, C, D, E) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>,
             Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>,
             Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>,
             Self::Target<(((((Self::Param, B), A), C), D), E)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn ap6<A, C, D, E, F, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B, C, D, E, F) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>,
             Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>,
             Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>,
             Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>,
             Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn ap7<A, C, D, E, F, G, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B, C, D, E, F, G) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>,
             Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>,
             Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>,
             Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>,
             Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>,
             Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn ap8<A, C, D, E, F, G, H, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        fh: Self::Target<H>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B, C, D, E, F, G, H) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>,
             Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>,
             Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>,
             Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>,
             Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>,
             Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<((((((((Self::Param, B), A), C), D), E), F), G), H)> = Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>>,
             Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn ap9<A, C, D, E, F, G, H, I, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        fh: Self::Target<H>,
        fi: Self::Target<I>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B, C, D, E, F, G, H, I) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>,
             Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>,
             Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>,
             Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>,
             Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>,
             Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<((((((((Self::Param, B), A), C), D), E), F), G), H)> = Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>>,
             Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)> = Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>>,
             Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn ap10<A, C, D, E, F, G, H, I, J, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        fh: Self::Target<H>,
        fi: Self::Target<I>,
        fj: Self::Target<J>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B, C, D, E, F, G, H, I, J) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>,
             Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>,
             Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>,
             Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>,
             Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>,
             Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<((((((((Self::Param, B), A), C), D), E), F), G), H)> = Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>>,
             Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)> = Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>>,
             Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)> = Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>>,
             Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn ap11<A, C, D, E, F, G, H, I, J, K, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        fh: Self::Target<H>,
        fi: Self::Target<I>,
        fj: Self::Target<J>,
        fk: Self::Target<K>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B, C, D, E, F, G, H, I, J, K) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>,
             Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>,
             Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>,
             Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>,
             Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>,
             Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<((((((((Self::Param, B), A), C), D), E), F), G), H)> = Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>>,
             Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)> = Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>>,
             Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)> = Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>>,
             Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>: Apply<K, Target<K> = Self::Target<K>> + Higher<Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)> = Self::Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)>>,
             Self::Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn ap12<A, C, D, E, F, G, H, I, J, K, L, Z>(
        self,
        fa: Self::Target<A>,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        fh: Self::Target<H>,
        fi: Self::Target<I>,
        fj: Self::Target<J>,
        fk: Self::Target<K>,
        fl: Self::Target<L>
    ) -> Self::Target<Z>
       where Self::Param: FnOnce(A, B, C, D, E, F, G, H, I, J, K, L) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>,
             Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>,
             Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>,
             Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>,
             Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>,
             Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>,
             Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<((((((((Self::Param, B), A), C), D), E), F), G), H)> = Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>>,
             Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)> = Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>>,
             Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)> = Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>>,
             Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>: Apply<K, Target<K> = Self::Target<K>> + Higher<Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)> = Self::Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)>>,
             Self::Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)>: Apply<L, Target<L> = Self::Target<L>> + Higher<Target<((((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K), L)> = Self::Target<((((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K), L)>>,
             Self::Target<((((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K), L)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn map2<Z, F>(self, fb: Self::Target<B>, f: F) -> Self::Target<Z>
       where F: FnMut(Self::Param, B) -> Z,
             Self::Target<(Self::Param, B)>: Functor<Z, Target<Z> = Self::Target<Z>>,
             Self: Sized { ... }
    fn map3<C, Z, F>(
        self,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        f: F
    ) -> Self::Target<Z>
       where F: FnMut(Self::Param, B, C) -> Z,
             Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>,
             Self::Target<((Self::Param, B), C)>: Functor<Z, Target<Z> = Self::Target<Z>>,
             Self: Sized { ... }
    fn map4<C, D, Z, FN>(
        self,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        func: FN
    ) -> Self::Target<Z>
       where FN: FnMut(Self::Param, B, C, D) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>,
             Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>,
             Self::Target<(((Self::Param, B), C), D)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn map5<C, D, E, Z, FN>(
        self,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        func: FN
    ) -> Self::Target<Z>
       where FN: FnMut(Self::Param, B, C, D, E) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>,
             Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>,
             Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>,
             Self::Target<((((Self::Param, B), C), D), E)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn map6<C, D, E, F, Z, FN>(
        self,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        func: FN
    ) -> Self::Target<Z>
       where FN: FnMut(Self::Param, B, C, D, E, F) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>,
             Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>,
             Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>,
             Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>,
             Self::Target<(((((Self::Param, B), C), D), E), F)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn map7<C, D, E, F, G, Z, FN>(
        self,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        func: FN
    ) -> Self::Target<Z>
       where FN: FnMut(Self::Param, B, C, D, E, F, G) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>,
             Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>,
             Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>,
             Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>,
             Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>,
             Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn map8<C, D, E, F, G, H, Z, FN>(
        self,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        fh: Self::Target<H>,
        func: FN
    ) -> Self::Target<Z>
       where FN: FnMut(Self::Param, B, C, D, E, F, G, H) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>,
             Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>,
             Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>,
             Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>,
             Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>,
             Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<(((((((Self::Param, B), C), D), E), F), G), H)> = Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>>,
             Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn map9<C, D, E, F, G, H, I, Z, FN>(
        self,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        fh: Self::Target<H>,
        fi: Self::Target<I>,
        func: FN
    ) -> Self::Target<Z>
       where FN: FnMut(Self::Param, B, C, D, E, F, G, H, I) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>,
             Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>,
             Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>,
             Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>,
             Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>,
             Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<(((((((Self::Param, B), C), D), E), F), G), H)> = Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>>,
             Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<((((((((Self::Param, B), C), D), E), F), G), H), I)> = Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>>,
             Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn map10<C, D, E, F, G, H, I, J, Z, FN>(
        self,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        fh: Self::Target<H>,
        fi: Self::Target<I>,
        fj: Self::Target<J>,
        func: FN
    ) -> Self::Target<Z>
       where FN: FnMut(Self::Param, B, C, D, E, F, G, H, I, J) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>,
             Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>,
             Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>,
             Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>,
             Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>,
             Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<(((((((Self::Param, B), C), D), E), F), G), H)> = Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>>,
             Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<((((((((Self::Param, B), C), D), E), F), G), H), I)> = Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>>,
             Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)> = Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>>,
             Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn map11<C, D, E, F, G, H, I, J, K, Z, FN>(
        self,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        fh: Self::Target<H>,
        fi: Self::Target<I>,
        fj: Self::Target<J>,
        fk: Self::Target<K>,
        func: FN
    ) -> Self::Target<Z>
       where FN: FnMut(Self::Param, B, C, D, E, F, G, H, I, J, K) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>,
             Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>,
             Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>,
             Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>,
             Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>,
             Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<(((((((Self::Param, B), C), D), E), F), G), H)> = Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>>,
             Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<((((((((Self::Param, B), C), D), E), F), G), H), I)> = Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>>,
             Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)> = Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>>,
             Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>: Apply<K, Target<K> = Self::Target<K>> + Higher<Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)> = Self::Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)>>,
             Self::Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn map12<C, D, E, F, G, H, I, J, K, L, Z, FN>(
        self,
        fb: Self::Target<B>,
        fc: Self::Target<C>,
        fd: Self::Target<D>,
        fe: Self::Target<E>,
        ff: Self::Target<F>,
        fg: Self::Target<G>,
        fh: Self::Target<H>,
        fi: Self::Target<I>,
        fj: Self::Target<J>,
        fk: Self::Target<K>,
        fl: Self::Target<L>,
        func: FN
    ) -> Self::Target<Z>
       where FN: FnMut(Self::Param, B, C, D, E, F, G, H, I, J, K, L) -> Z,
             Self: Sized,
             Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>,
             Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>,
             Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>,
             Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>,
             Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>,
             Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<(((((((Self::Param, B), C), D), E), F), G), H)> = Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>>,
             Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<((((((((Self::Param, B), C), D), E), F), G), H), I)> = Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>>,
             Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)> = Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>>,
             Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>: Apply<K, Target<K> = Self::Target<K>> + Higher<Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)> = Self::Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)>>,
             Self::Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)>: Apply<L, Target<L> = Self::Target<L>> + Higher<Target<(((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K), L)> = Self::Target<(((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K), L)>>,
             Self::Target<(((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K), L)>: Functor<Z, Target<Z> = Self::Target<Z>> { ... }
    fn product_r(self, fb: Self::Target<B>) -> Self::Target<B>
       where Self::Target<(Self::Param, B)>: Functor<B, Target<B> = Self::Target<B>>,
             Self: Sized { ... }
    fn product_l(self, fb: Self::Target<B>) -> Self
       where Self::Target<(Self::Param, B)>: Functor<Self::Param, Target<Self::Param> = Self>,
             Self: Higher<Target<<Self as Higher>::Param> = Self> + Sized { ... }
}

Weaker version of Applicative has apply but not pure.

Required Methods

fn ap<A>(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnOnce(A) -> B,

Apply a function in a context to a value in a context.

Examples

use rust2fun::prelude::*;

let f = Some(|x: i32| x.to_string());
assert_eq!(Some("1".to_string()), f.ap(Some(1)));
assert_eq!(Some("2".to_string()), f.ap(Some(2)));

Provided Methods

fn ap2<A, Z>(self, fa: Self::Target<A>, fb: Self::Target<B>) -> Self::Target<Z>where Self::Param: FnOnce(A, B) -> Z, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Functor<Z, Target<Z> = Self::Target<Z>>, Self: Sized,

Is a binary version of Apply::ap.

Examples

use rust2fun::prelude::*;

let f = Some(|x, y| x + y);
assert_eq!(Some(3), f.ap2(Some(1), Some(2)));

fn ap3<A, C, Z>( self, fa: Self::Target<A>, fb: Self::Target<B>, fc: Self::Target<C> ) -> Self::Target<Z>where Self::Param: FnOnce(A, B, C) -> Z, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>, Self::Target<(((Self::Param, B), A), C)>: Functor<Z, Target<Z> = Self::Target<Z>>, Self: Sized,

Is a ternary version of Apply::ap.

Examples

use rust2fun::prelude::*;

let f = Some(|x, y, z| x + y + z);
assert_eq!(Some(6), f.ap3(Some(1), Some(2), Some(3)));

fn ap4<A, C, D, Z>( self, fa: Self::Target<A>, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D> ) -> Self::Target<Z>where Self::Param: FnOnce(A, B, C, D) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>, Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>, Self::Target<((((Self::Param, B), A), C), D)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::ap for a function of 4 arguments.

fn ap5<A, C, D, E, Z>( self, fa: Self::Target<A>, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E> ) -> Self::Target<Z>where Self::Param: FnOnce(A, B, C, D, E) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>, Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>, Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>, Self::Target<(((((Self::Param, B), A), C), D), E)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::ap for a function of 5 arguments.

fn ap6<A, C, D, E, F, Z>( self, fa: Self::Target<A>, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F> ) -> Self::Target<Z>where Self::Param: FnOnce(A, B, C, D, E, F) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>, Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>, Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>, Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>, Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::ap for a function of 6 arguments.

fn ap7<A, C, D, E, F, G, Z>( self, fa: Self::Target<A>, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G> ) -> Self::Target<Z>where Self::Param: FnOnce(A, B, C, D, E, F, G) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>, Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>, Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>, Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>, Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>, Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::ap for a function of 7 arguments.

fn ap8<A, C, D, E, F, G, H, Z>( self, fa: Self::Target<A>, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, fh: Self::Target<H> ) -> Self::Target<Z>where Self::Param: FnOnce(A, B, C, D, E, F, G, H) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>, Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>, Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>, Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>, Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>, Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<((((((((Self::Param, B), A), C), D), E), F), G), H)> = Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>>, Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::ap for a function of 8 arguments.

fn ap9<A, C, D, E, F, G, H, I, Z>( self, fa: Self::Target<A>, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, fh: Self::Target<H>, fi: Self::Target<I> ) -> Self::Target<Z>where Self::Param: FnOnce(A, B, C, D, E, F, G, H, I) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>, Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>, Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>, Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>, Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>, Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<((((((((Self::Param, B), A), C), D), E), F), G), H)> = Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>>, Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)> = Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>>, Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::ap for a function of 9 arguments.

fn ap10<A, C, D, E, F, G, H, I, J, Z>( self, fa: Self::Target<A>, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, fh: Self::Target<H>, fi: Self::Target<I>, fj: Self::Target<J> ) -> Self::Target<Z>where Self::Param: FnOnce(A, B, C, D, E, F, G, H, I, J) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>, Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>, Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>, Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>, Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>, Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<((((((((Self::Param, B), A), C), D), E), F), G), H)> = Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>>, Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)> = Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>>, Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)> = Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>>, Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::ap for a function of 10 arguments.

fn ap11<A, C, D, E, F, G, H, I, J, K, Z>( self, fa: Self::Target<A>, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, fh: Self::Target<H>, fi: Self::Target<I>, fj: Self::Target<J>, fk: Self::Target<K> ) -> Self::Target<Z>where Self::Param: FnOnce(A, B, C, D, E, F, G, H, I, J, K) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>, Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>, Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>, Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>, Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>, Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<((((((((Self::Param, B), A), C), D), E), F), G), H)> = Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>>, Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)> = Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>>, Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)> = Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>>, Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>: Apply<K, Target<K> = Self::Target<K>> + Higher<Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)> = Self::Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)>>, Self::Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::ap for a function of 11 arguments.

fn ap12<A, C, D, E, F, G, H, I, J, K, L, Z>( self, fa: Self::Target<A>, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, fh: Self::Target<H>, fi: Self::Target<I>, fj: Self::Target<J>, fk: Self::Target<K>, fl: Self::Target<L> ) -> Self::Target<Z>where Self::Param: FnOnce(A, B, C, D, E, F, G, H, I, J, K, L) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<A, Target<A> = Self::Target<A>> + Higher<Target<((Self::Param, B), A)> = Self::Target<((Self::Param, B), A)>>, Self::Target<((Self::Param, B), A)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<(((Self::Param, B), A), C)> = Self::Target<(((Self::Param, B), A), C)>>, Self::Target<(((Self::Param, B), A), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<((((Self::Param, B), A), C), D)> = Self::Target<((((Self::Param, B), A), C), D)>>, Self::Target<((((Self::Param, B), A), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<(((((Self::Param, B), A), C), D), E)> = Self::Target<(((((Self::Param, B), A), C), D), E)>>, Self::Target<(((((Self::Param, B), A), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<((((((Self::Param, B), A), C), D), E), F)> = Self::Target<((((((Self::Param, B), A), C), D), E), F)>>, Self::Target<((((((Self::Param, B), A), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<(((((((Self::Param, B), A), C), D), E), F), G)> = Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>>, Self::Target<(((((((Self::Param, B), A), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<((((((((Self::Param, B), A), C), D), E), F), G), H)> = Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>>, Self::Target<((((((((Self::Param, B), A), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)> = Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>>, Self::Target<(((((((((Self::Param, B), A), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)> = Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>>, Self::Target<((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J)>: Apply<K, Target<K> = Self::Target<K>> + Higher<Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)> = Self::Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)>>, Self::Target<(((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K)>: Apply<L, Target<L> = Self::Target<L>> + Higher<Target<((((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K), L)> = Self::Target<((((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K), L)>>, Self::Target<((((((((((((Self::Param, B), A), C), D), E), F), G), H), I), J), K), L)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::ap for a function of 12 arguments.

fn map2<Z, F>(self, fb: Self::Target<B>, f: F) -> Self::Target<Z>where F: FnMut(Self::Param, B) -> Z, Self::Target<(Self::Param, B)>: Functor<Z, Target<Z> = Self::Target<Z>>, Self: Sized,

Combine two effectful values into a single effectful value using a binary function.

Examples

use rust2fun::prelude::*;

let x = Some(1);
let y = Some(2);
let actual = x.map2(y, |x, y| x + y);
assert_eq!(Some(3), actual);

fn map3<C, Z, F>( self, fb: Self::Target<B>, fc: Self::Target<C>, f: F ) -> Self::Target<Z>where F: FnMut(Self::Param, B, C) -> Z, Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>, Self::Target<((Self::Param, B), C)>: Functor<Z, Target<Z> = Self::Target<Z>>, Self: Sized,

Combine three effectful values into a single effectful value using a ternary function.

Examples

use rust2fun::prelude::*;

let x = Some(1);
let y = Some(2);
let z = Some(3);
let actual = x.map3(y, z, |x, y, z| x + y + z);
assert_eq!(Some(6), actual);

fn map4<C, D, Z, FN>( self, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, func: FN ) -> Self::Target<Z>where FN: FnMut(Self::Param, B, C, D) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>, Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>, Self::Target<(((Self::Param, B), C), D)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::map2 for a function of 4 arguments.

fn map5<C, D, E, Z, FN>( self, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, func: FN ) -> Self::Target<Z>where FN: FnMut(Self::Param, B, C, D, E) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>, Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>, Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>, Self::Target<((((Self::Param, B), C), D), E)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::map2 for a function of 5 arguments.

fn map6<C, D, E, F, Z, FN>( self, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, func: FN ) -> Self::Target<Z>where FN: FnMut(Self::Param, B, C, D, E, F) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>, Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>, Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>, Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>, Self::Target<(((((Self::Param, B), C), D), E), F)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::map2 for a function of 6 arguments.

fn map7<C, D, E, F, G, Z, FN>( self, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, func: FN ) -> Self::Target<Z>where FN: FnMut(Self::Param, B, C, D, E, F, G) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>, Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>, Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>, Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>, Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>, Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::map2 for a function of 7 arguments.

fn map8<C, D, E, F, G, H, Z, FN>( self, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, fh: Self::Target<H>, func: FN ) -> Self::Target<Z>where FN: FnMut(Self::Param, B, C, D, E, F, G, H) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>, Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>, Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>, Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>, Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>, Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<(((((((Self::Param, B), C), D), E), F), G), H)> = Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>>, Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::map2 for a function of 8 arguments.

fn map9<C, D, E, F, G, H, I, Z, FN>( self, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, fh: Self::Target<H>, fi: Self::Target<I>, func: FN ) -> Self::Target<Z>where FN: FnMut(Self::Param, B, C, D, E, F, G, H, I) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>, Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>, Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>, Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>, Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>, Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<(((((((Self::Param, B), C), D), E), F), G), H)> = Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>>, Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<((((((((Self::Param, B), C), D), E), F), G), H), I)> = Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>>, Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::map2 for a function of 9 arguments.

fn map10<C, D, E, F, G, H, I, J, Z, FN>( self, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, fh: Self::Target<H>, fi: Self::Target<I>, fj: Self::Target<J>, func: FN ) -> Self::Target<Z>where FN: FnMut(Self::Param, B, C, D, E, F, G, H, I, J) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>, Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>, Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>, Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>, Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>, Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<(((((((Self::Param, B), C), D), E), F), G), H)> = Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>>, Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<((((((((Self::Param, B), C), D), E), F), G), H), I)> = Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>>, Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)> = Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>>, Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::map2 for a function of 10 arguments.

fn map11<C, D, E, F, G, H, I, J, K, Z, FN>( self, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, fh: Self::Target<H>, fi: Self::Target<I>, fj: Self::Target<J>, fk: Self::Target<K>, func: FN ) -> Self::Target<Z>where FN: FnMut(Self::Param, B, C, D, E, F, G, H, I, J, K) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>, Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>, Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>, Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>, Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>, Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<(((((((Self::Param, B), C), D), E), F), G), H)> = Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>>, Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<((((((((Self::Param, B), C), D), E), F), G), H), I)> = Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>>, Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)> = Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>>, Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>: Apply<K, Target<K> = Self::Target<K>> + Higher<Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)> = Self::Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)>>, Self::Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::map2 for a function of 11 arguments.

fn map12<C, D, E, F, G, H, I, J, K, L, Z, FN>( self, fb: Self::Target<B>, fc: Self::Target<C>, fd: Self::Target<D>, fe: Self::Target<E>, ff: Self::Target<F>, fg: Self::Target<G>, fh: Self::Target<H>, fi: Self::Target<I>, fj: Self::Target<J>, fk: Self::Target<K>, fl: Self::Target<L>, func: FN ) -> Self::Target<Z>where FN: FnMut(Self::Param, B, C, D, E, F, G, H, I, J, K, L) -> Z, Self: Sized, Self::Target<(Self::Param, B)>: Apply<C, Target<C> = Self::Target<C>> + Higher<Target<((Self::Param, B), C)> = Self::Target<((Self::Param, B), C)>>, Self::Target<((Self::Param, B), C)>: Apply<D, Target<D> = Self::Target<D>> + Higher<Target<(((Self::Param, B), C), D)> = Self::Target<(((Self::Param, B), C), D)>>, Self::Target<(((Self::Param, B), C), D)>: Apply<E, Target<E> = Self::Target<E>> + Higher<Target<((((Self::Param, B), C), D), E)> = Self::Target<((((Self::Param, B), C), D), E)>>, Self::Target<((((Self::Param, B), C), D), E)>: Apply<F, Target<F> = Self::Target<F>> + Higher<Target<(((((Self::Param, B), C), D), E), F)> = Self::Target<(((((Self::Param, B), C), D), E), F)>>, Self::Target<(((((Self::Param, B), C), D), E), F)>: Apply<G, Target<G> = Self::Target<G>> + Higher<Target<((((((Self::Param, B), C), D), E), F), G)> = Self::Target<((((((Self::Param, B), C), D), E), F), G)>>, Self::Target<((((((Self::Param, B), C), D), E), F), G)>: Apply<H, Target<H> = Self::Target<H>> + Higher<Target<(((((((Self::Param, B), C), D), E), F), G), H)> = Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>>, Self::Target<(((((((Self::Param, B), C), D), E), F), G), H)>: Apply<I, Target<I> = Self::Target<I>> + Higher<Target<((((((((Self::Param, B), C), D), E), F), G), H), I)> = Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>>, Self::Target<((((((((Self::Param, B), C), D), E), F), G), H), I)>: Apply<J, Target<J> = Self::Target<J>> + Higher<Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)> = Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>>, Self::Target<(((((((((Self::Param, B), C), D), E), F), G), H), I), J)>: Apply<K, Target<K> = Self::Target<K>> + Higher<Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)> = Self::Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)>>, Self::Target<((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K)>: Apply<L, Target<L> = Self::Target<L>> + Higher<Target<(((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K), L)> = Self::Target<(((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K), L)>>, Self::Target<(((((((((((Self::Param, B), C), D), E), F), G), H), I), J), K), L)>: Functor<Z, Target<Z> = Self::Target<Z>>,

Is a version of Apply::map2 for a function of 12 arguments.

fn product_r(self, fb: Self::Target<B>) -> Self::Target<B>where Self::Target<(Self::Param, B)>: Functor<B, Target<B> = Self::Target<B>>, Self: Sized,

Compose two effectful values discarding the result of the first.

Examples

use rust2fun::prelude::*;

let x = Some(1);
let y = Some(2);
let actual = x.product_r(y);
assert_eq!(Some(2), actual);

fn product_l(self, fb: Self::Target<B>) -> Selfwhere Self::Target<(Self::Param, B)>: Functor<Self::Param, Target<Self::Param> = Self>, Self: Higher<Target<<Self as Higher>::Param> = Self> + Sized,

Compose two effectful values discarding the result of the second.

Examples

use rust2fun::prelude::*;

let x = Some(1);
let y = Some(2);
let actual = x.product_l(y);
assert_eq!(Some(1), actual);

Implementations on Foreign Types

impl<F: Ord, B: Ord> Apply<B> for BTreeSet<F>

fn ap<A>(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnOnce(A) -> B,

impl<F: Eq + Hash, B: Eq + Hash> Apply<B> for HashSet<F>

fn ap<A>(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnOnce(A) -> B,

impl<F, B> Apply<B> for LinkedList<F>

fn ap<A>(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnOnce(A) -> B,

impl<F, B> Apply<B> for PhantomData<F>

fn ap<A>(self, _fa: PhantomData<A>) -> PhantomData<B>where Self::Param: FnOnce(A) -> B,

impl<F, B> Apply<B> for Option<F>

fn ap<A>(self, fa: Option<A>) -> Option<B>where Self::Param: FnOnce(A) -> B,

impl<F, B> Apply<B> for VecDeque<F>

fn ap<A>(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnOnce(A) -> B,

impl<F, B, K: Eq + Hash> Apply<B> for HashMap<K, F>

fn ap<A>(self, fa: HashMap<K, A>) -> HashMap<K, B>where Self::Param: FnOnce(A) -> B,

impl<F: Ord, B: Ord> Apply<B> for BinaryHeap<F>

fn ap<A>(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnOnce(A) -> B,

impl<F, B> Apply<B> for Vec<F>

fn ap<A>(self, fa: Self::Target<A>) -> Self::Target<B>where Self::Param: FnOnce(A) -> B,

impl<F, B, E> Apply<B> for Result<F, E>

fn ap<A>(self, fa: Result<A, E>) -> Result<B, E>where Self::Param: FnOnce(A) -> B,

impl<F, B> Apply<B> for Box<F>

fn ap<A>(self, fa: Box<A>) -> Box<B>where Self::Param: FnOnce(A) -> B,

Implementors

impl<F, B> Apply<B> for NEVec<F>

impl<F, B, E: Semigroup> Apply<B> for Validated<F, E>