Interface Profunctor<A,​B,​PF extends Profunctor<?,​?,​PF>>

    • Method Detail

      • diMap

        <Z,​C> Profunctor<Z,​C,​PF> diMap​(Fn1<? super Z,​? extends A> lFn,
                                                         Fn1<? super B,​? extends C> rFn)
        Dually map contravariantly over the left parameter and covariantly over the right parameter. This is isomorphic to diMapL(lFn).diMapR(rFn).
        Type Parameters:
        Z - the new left parameter type
        C - the new right parameter type
        Parameters:
        lFn - the left parameter mapping function
        rFn - the right parameter mapping function
        Returns:
        a profunctor over Z (the new left parameter type) and C (the new right parameter type)
      • diMapL

        default <Z> Profunctor<Z,​B,​PF> diMapL​(Fn1<? super Z,​? extends A> fn)
        Contravariantly map over the left parameter.
        Type Parameters:
        Z - the new left parameter type
        Parameters:
        fn - the mapping function
        Returns:
        a profunctor over Z (the new left parameter type) and C (the same right parameter type)
      • diMapR

        default <C> Profunctor<A,​C,​PF> diMapR​(Fn1<? super B,​? extends C> fn)
        Covariantly map over the right parameter. For all profunctors that are also functors, it should hold that diMapR(f) == fmap(f).
        Type Parameters:
        C - the new right parameter type
        Parameters:
        fn - the mapping function
        Returns:
        a profunctor over A (the same left parameter type) and C (the new right parameter type)
      • contraMap

        default <Z> Profunctor<Z,​B,​PF> contraMap​(Fn1<? super Z,​? extends A> fn)
        Contravariantly map A <- B.
        Specified by:
        contraMap in interface Contravariant<A,​B>
        Type Parameters:
        Z - the new parameter type
        Parameters:
        fn - the mapping function
        Returns:
        the mapped Contravariant functor instance