A
- The first argument typeB
- The second argument typeC
- The third argument typeD
- The fourth argument typeE
- The return type@FunctionalInterface public interface Fn4<A,B,C,D,E> extends Fn3<A,B,C,Fn1<D,E>>
Fn3
, so similarly auto-curried.Fn3
Modifier and Type | Method and Description |
---|---|
default Fn3<B,C,D,E> |
apply(A a)
Partially apply this function by taking its first argument.
|
default Fn2<C,D,E> |
apply(A a,
B b)
Partially apply this function by taking its first two arguments.
|
default Fn1<D,E> |
apply(A a,
B b,
C c)
Partially apply this function by taking its first three arguments.
|
default E |
apply(A a,
B b,
C c,
D d)
Invoke this function with the given arguments.
|
default Fn1<D,E> |
checkedApply(A a,
B b,
C c) |
E |
checkedApply(A a,
B b,
C c,
D d) |
default <Y,Z> Fn5<Y,Z,B,C,D,E> |
compose(Fn2<? super Y,? super Z,? extends A> before)
Right-to-left composition between different arity functions.
|
default <Z> Fn4<Z,B,C,D,E> |
contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B . |
default <Z> Fn4<Z,B,C,D,E> |
diMapL(Fn1<? super Z,? extends A> fn)
Contravariantly map over the argument to this function, producing a function that takes the new argument type,
and produces the same result.
|
default <F> Fn4<A,B,C,D,E> |
discardR(Applicative<F,Fn1<A,?>> appB)
Sequence both this
Applicative and appB , discarding appB's result and
returning this Applicative . |
default Fn4<B,A,C,D,E> |
flip()
Flip the order of the first two arguments.
|
static <A,B,C,D,E> |
fn4(Fn1<A,Fn3<B,C,D,E>> curriedFn1)
|
static <A,B,C,D,E> |
fn4(Fn2<A,B,Fn2<C,D,E>> curriedFn2)
|
static <A,B,C,D,E> |
fn4(Fn3<A,B,C,Fn1<D,E>> curriedFn3)
|
static <A,B,C,D,E> |
fn4(Fn4<A,B,C,D,E> fn)
Static factory method for coercing a lambda to an
Fn4 . |
default Fn3<? super Product2<? extends A,? extends B>,C,D,E> |
uncurry()
|
default <Z> Fn5<Z,A,B,C,D,E> |
widen()
Widen this function's argument list by prepending an ignored argument of any type to the front.
|
checkedApply, fn3, fn3, fn3
checkedApply, curried, curry, fn2, fromBiFunction, toBiFunction
default E apply(A a, B b, C c, D d)
a
- the first argumentb
- the second argumentc
- the third argumentd
- the fourth argumentdefault <Z> Fn5<Z,A,B,C,D,E> widen()
default Fn2<C,D,E> apply(A a, B b)
default Fn1<D,E> apply(A a, B b, C c)
default <F> Fn4<A,B,C,D,E> discardR(Applicative<F,Fn1<A,?>> appB)
Fn2
Applicative
and appB
, discarding appB's
result and
returning this Applicative
. This is generally useful for sequentially performing side-effects.discardR
in interface Applicative<Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<A,?>>
discardR
in interface Fn1<A,Fn1<B,Fn1<C,Fn1<D,E>>>>
discardR
in interface Fn2<A,B,Fn1<C,Fn1<D,E>>>
discardR
in interface Fn3<A,B,C,Fn1<D,E>>
discardR
in interface Monad<Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<A,?>>
discardR
in interface MonadReader<A,Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<A,?>>
discardR
in interface MonadRec<Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<A,?>>
discardR
in interface MonadWriter<A,Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<A,?>>
F
- the type of appB's parameterappB
- the other Applicativedefault <Z> Fn4<Z,B,C,D,E> diMapL(Fn1<? super Z,? extends A> fn)
Fn2
diMapL
in interface Cartesian<A,Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<?,?>>
diMapL
in interface Cocartesian<A,Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<?,?>>
diMapL
in interface Fn1<A,Fn1<B,Fn1<C,Fn1<D,E>>>>
diMapL
in interface Fn2<A,B,Fn1<C,Fn1<D,E>>>
diMapL
in interface Fn3<A,B,C,Fn1<D,E>>
diMapL
in interface Profunctor<A,Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<?,?>>
Z
- the new argument typefn
- the contravariant argument mapping functionFn1
<Z, B>default <Z> Fn4<Z,B,C,D,E> contraMap(Fn1<? super Z,? extends A> fn)
Fn2
A <- B
.contraMap
in interface Cartesian<A,Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<?,?>>
contraMap
in interface Cocartesian<A,Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<?,?>>
contraMap
in interface Contravariant<A,Profunctor<?,Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<?,?>>>
contraMap
in interface Fn1<A,Fn1<B,Fn1<C,Fn1<D,E>>>>
contraMap
in interface Fn2<A,B,Fn1<C,Fn1<D,E>>>
contraMap
in interface Fn3<A,B,C,Fn1<D,E>>
contraMap
in interface Profunctor<A,Fn1<B,Fn1<C,Fn1<D,E>>>,Fn1<?,?>>
Z
- the new parameter typefn
- the mapping functiondefault <Y,Z> Fn5<Y,Z,B,C,D,E> compose(Fn2<? super Y,? super Z,? extends A> before)
Fn2
compose
in interface Fn1<A,Fn1<B,Fn1<C,Fn1<D,E>>>>
compose
in interface Fn2<A,B,Fn1<C,Fn1<D,E>>>
compose
in interface Fn3<A,B,C,Fn1<D,E>>
Y
- the resulting function's first argument typeZ
- the resulting function's second argument typebefore
- the function to pass its return value to this function's inputFn2
<Y, Z, B>static <A,B,C,D,E> Fn4<A,B,C,D,E> fn4(Fn1<A,Fn3<B,C,D,E>> curriedFn1)
A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the output typecurriedFn1
- the curried fn1 to adaptFn4
static <A,B,C,D,E> Fn4<A,B,C,D,E> fn4(Fn2<A,B,Fn2<C,D,E>> curriedFn2)
A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the output typecurriedFn2
- the curried fn2 to adaptFn4
static <A,B,C,D,E> Fn4<A,B,C,D,E> fn4(Fn3<A,B,C,Fn1<D,E>> curriedFn3)
A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the output typecurriedFn3
- the curried fn3 to adaptFn4
static <A,B,C,D,E> Fn4<A,B,C,D,E> fn4(Fn4<A,B,C,D,E> fn)
Fn4
.A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the output typefn
- the lambda to coerceFn4