Interface Fn3<A,​B,​C,​D>

    • Method Detail

      • checkedApply

        D checkedApply​(A a,
                       B b,
                       C c)
                throws java.lang.Throwable
        Throws:
        java.lang.Throwable
      • apply

        default D apply​(A a,
                        B b,
                        C c)
        Invoke this function with the given arguments.
        Parameters:
        a - the first argument
        b - the second argument
        c - the third argument
        Returns:
        the result of the function application
      • checkedApply

        default Fn1<C,​D> checkedApply​(A a,
                                            B b)
                                     throws java.lang.Throwable
        Specified by:
        checkedApply in interface Fn2<A,​B,​C>
        Throws:
        java.lang.Throwable
      • widen

        default <Z> Fn4<Z,​A,​B,​C,​D> widen()
        Widen this function's argument list by prepending an ignored argument of any type to the front.
        Specified by:
        widen in interface Fn1<A,​B>
        Specified by:
        widen in interface Fn2<A,​B,​C>
        Type Parameters:
        Z - the new first argument type
        Returns:
        the widened function
      • apply

        default Fn2<B,​C,​D> apply​(A a)
        Partially apply this function by taking its first argument.
        Specified by:
        apply in interface Fn1<A,​B>
        Specified by:
        apply in interface Fn2<A,​B,​C>
        Parameters:
        a - the first argument
        Returns:
        an Fn2<B, C, D>
      • apply

        default Fn1<C,​D> apply​(A a,
                                     B b)
        Partially apply this function by taking its first two arguments.
        Specified by:
        apply in interface Fn2<A,​B,​C>
        Parameters:
        a - the first argument
        b - the second argument
        Returns:
        an Fn1<C, D>
      • flip

        default Fn3<B,​A,​C,​D> flip()
        Flip the order of the first two arguments.
        Specified by:
        flip in interface Fn2<A,​B,​C>
        Returns:
        an Fn3<B, A, C, D>
      • uncurry

        default Fn2<? super Product2<? extends A,​? extends B>,​C,​D> uncurry()
        Returns an Fn2 that takes the first two arguments as a Product2<A, B> and the third argument.
        Specified by:
        uncurry in interface Fn2<A,​B,​C>
        Returns:
        an Fn2 taking a Product2 and the third argument
      • discardR

        default <E> Fn3<A,​B,​C,​D> discardR​(Applicative<E,​Fn1<A,​?>> appB)
        Description copied from interface: Fn2
        Sequence both this Applicative and appB, discarding appB's result and returning this Applicative. This is generally useful for sequentially performing side-effects.
        Specified by:
        discardR in interface Applicative<A,​B>
        Specified by:
        discardR in interface Fn1<A,​B>
        Specified by:
        discardR in interface Fn2<A,​B,​C>
        Specified by:
        discardR in interface Monad<A,​B>
        Specified by:
        discardR in interface MonadReader<A,​B,​C>
        Specified by:
        discardR in interface MonadRec<A,​B>
        Specified by:
        discardR in interface MonadWriter<A,​B,​C>
        Type Parameters:
        E - the type of appB's parameter
        Parameters:
        appB - the other Applicative
        Returns:
        this Applicative
      • diMapL

        default <Z> Fn3<Z,​B,​C,​D> diMapL​(Fn1<? super Z,​? extends A> fn)
        Description copied from interface: Fn2
        Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
        Specified by:
        diMapL in interface Cartesian<A,​B,​C>
        Specified by:
        diMapL in interface Cocartesian<A,​B,​C>
        Specified by:
        diMapL in interface Fn1<A,​B>
        Specified by:
        diMapL in interface Fn2<A,​B,​C>
        Specified by:
        diMapL in interface Profunctor<A,​B,​C>
        Type Parameters:
        Z - the new argument type
        Parameters:
        fn - the contravariant argument mapping function
        Returns:
        an Fn1<Z, B>
      • compose

        default <Y,​Z> Fn4<Y,​Z,​B,​C,​D> compose​(Fn2<? super Y,​? super Z,​? extends A> before)
        Description copied from interface: Fn2
        Right-to-left composition between different arity functions. Preserves highest arity in the return type.
        Specified by:
        compose in interface Fn1<A,​B>
        Specified by:
        compose in interface Fn2<A,​B,​C>
        Type Parameters:
        Y - the resulting function's first argument type
        Z - the resulting function's second argument type
        Parameters:
        before - the function to pass its return value to this function's input
        Returns:
        an Fn2<Y, Z, B>
      • fn3

        static <A,​B,​C,​D> Fn3<A,​B,​C,​D> fn3​(Fn1<A,​Fn2<B,​C,​D>> curriedFn1)
        Static factory method for wrapping a curried Fn1 in an Fn3.
        Type Parameters:
        A - the first input argument type
        B - the second input argument type
        C - the third input argument type
        D - the output type
        Parameters:
        curriedFn1 - the curried fn1 to adapt
        Returns:
        the Fn3
      • fn3

        static <A,​B,​C,​D> Fn3<A,​B,​C,​D> fn3​(Fn2<A,​B,​Fn1<C,​D>> curriedFn2)
        Static factory method for wrapping a curried Fn2 in an Fn3.
        Type Parameters:
        A - the first input argument type
        B - the second input argument type
        C - the third input argument type
        D - the output type
        Parameters:
        curriedFn2 - the curried fn2 to adapt
        Returns:
        the Fn3
      • fn3

        static <A,​B,​C,​D> Fn3<A,​B,​C,​D> fn3​(Fn3<A,​B,​C,​D> fn)
        Static factory method for coercing a lambda to an Fn3.
        Type Parameters:
        A - the first input argument type
        B - the second input argument type
        C - the third input argument type
        D - the output type
        Parameters:
        fn - the lambda to coerce
        Returns:
        the Fn3