A
- The first argument typeB
- The second argument typeC
- The third argument typeD
- The fourth argument typeE
- The fifth argument typeF
- The sixth argument typeG
- The seventh argument typeH
- The eighth argument typeI
- The return type@FunctionalInterface public interface Fn8<A,B,C,D,E,F,G,H,I> extends Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
Fn7
, so similarly auto-curried.Fn7
Modifier and Type | Method and Description |
---|---|
default Fn7<B,C,D,E,F,G,H,I> |
apply(A a)
Partially apply this function by taking its first argument.
|
default Fn6<C,D,E,F,G,H,I> |
apply(A a,
B b)
Partially apply this function by taking its first two arguments.
|
default Fn5<D,E,F,G,H,I> |
apply(A a,
B b,
C c)
Partially apply this function by taking its first three arguments.
|
default Fn4<E,F,G,H,I> |
apply(A a,
B b,
C c,
D d)
Partially apply this function by taking its first four arguments.
|
default Fn3<F,G,H,I> |
apply(A a,
B b,
C c,
D d,
E e)
Partially apply this function by taking its first five arguments.
|
default Fn2<G,H,I> |
apply(A a,
B b,
C c,
D d,
E e,
F f)
Partially apply this function by taking its first six arguments.
|
default Fn1<H,I> |
apply(A a,
B b,
C c,
D d,
E e,
F f,
G g)
Partially apply this function by taking its first seven arguments.
|
default I |
apply(A a,
B b,
C c,
D d,
E e,
F f,
G g,
H h)
Invoke this function with the given arguments.
|
default Fn1<H,I> |
checkedApply(A a,
B b,
C c,
D d,
E e,
F f,
G g) |
I |
checkedApply(A a,
B b,
C c,
D d,
E e,
F f,
G g,
H h) |
default <Y,Z> Fn8<Y,Z,B,C,D,E,F,G,Fn1<H,I>> |
compose(Fn2<? super Y,? super Z,? extends A> before)
Right-to-left composition between different arity functions.
|
default <Z> Fn8<Z,B,C,D,E,F,G,H,I> |
contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B . |
default <Z> Fn8<Z,B,C,D,E,F,G,H,I> |
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 <J> Fn8<A,B,C,D,E,F,G,H,I> |
discardR(Applicative<J,Fn1<A,?>> appB)
Sequence both this
Applicative and appB , discarding appB's result and
returning this Applicative . |
default Fn8<B,A,C,D,E,F,G,H,I> |
flip()
Flip the order of the first two arguments.
|
static <A,B,C,D,E,F,G,H,I> |
fn8(Fn1<A,Fn7<B,C,D,E,F,G,H,I>> curriedFn1)
|
static <A,B,C,D,E,F,G,H,I> |
fn8(Fn2<A,B,Fn6<C,D,E,F,G,H,I>> curriedFn2)
|
static <A,B,C,D,E,F,G,H,I> |
fn8(Fn3<A,B,C,Fn5<D,E,F,G,H,I>> curriedFn3)
|
static <A,B,C,D,E,F,G,H,I> |
fn8(Fn4<A,B,C,D,Fn4<E,F,G,H,I>> curriedFn4)
|
static <A,B,C,D,E,F,G,H,I> |
fn8(Fn5<A,B,C,D,E,Fn3<F,G,H,I>> curriedFn5)
|
static <A,B,C,D,E,F,G,H,I> |
fn8(Fn6<A,B,C,D,E,F,Fn2<G,H,I>> curriedFn6)
|
static <A,B,C,D,E,F,G,H,I> |
fn8(Fn7<A,B,C,D,E,F,G,Fn1<H,I>> curriedFn7)
|
static <A,B,C,D,E,F,G,H,I> |
fn8(Fn8<A,B,C,D,E,F,G,H,I> fn)
Static factory method for coercing a lambda to an
Fn8 . |
default Fn7<? super Product2<? extends A,? extends B>,C,D,E,F,G,H,I> |
uncurry()
|
checkedApply, fn7, fn7, fn7, fn7, fn7, fn7, fn7, widen
checkedApply, fn6, fn6, fn6, fn6, fn6, fn6
checkedApply, fn5, fn5, fn5, fn5, fn5
checkedApply, fn4, fn4, fn4, fn4
checkedApply, fn3, fn3, fn3
checkedApply, curried, curry, fn2, fromBiFunction, toBiFunction
I checkedApply(A a, B b, C c, D d, E e, F f, G g, H h) throws Throwable
Throwable
default I apply(A a, B b, C c, D d, E e, F f, G g, H h)
a
- the first argumentb
- the second argumentc
- the third argumentd
- the fourth argumente
- the fifth argumentf
- the sixth argumentg
- the seventh argumenth
- the eighth argumentdefault Fn7<B,C,D,E,F,G,H,I> apply(A a)
apply
in interface Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>>
apply
in interface Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>
apply
in interface Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>
apply
in interface Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>
apply
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
apply
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
apply
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
a
- the first argumentFn7
that takes the remaining arguments and returns the resultdefault Fn6<C,D,E,F,G,H,I> apply(A a, B b)
apply
in interface Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>
apply
in interface Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>
apply
in interface Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>
apply
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
apply
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
apply
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
a
- the first argumentb
- the second argumentFn6
that takes the remaining arguments and returns the resultdefault Fn5<D,E,F,G,H,I> apply(A a, B b, C c)
apply
in interface Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>
apply
in interface Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>
apply
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
apply
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
apply
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
a
- the first argumentb
- the second argumentc
- the third argumentFn5
that takes remaining arguments and returns the resultdefault Fn4<E,F,G,H,I> apply(A a, B b, C c, D d)
apply
in interface Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>
apply
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
apply
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
apply
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
a
- the first argumentb
- the second argumentc
- the third argumentd
- the fourth argumentFn4
that takes the remaining arguments and returns the resultdefault Fn3<F,G,H,I> apply(A a, B b, C c, D d, E e)
apply
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
apply
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
apply
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
a
- the first argumentb
- the second argumentc
- the third argumentd
- the fourth argumente
- the fifth argumentFn3
that takes the remaining arguments and returns the resultdefault Fn2<G,H,I> apply(A a, B b, C c, D d, E e, F f)
apply
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
apply
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
a
- the first argumentb
- the second argumentc
- the third argumentd
- the fourth argumente
- the fifth argumentf
- the sixth argumentFn2
that takes the remaining arguments and returns the resultdefault Fn1<H,I> apply(A a, B b, C c, D d, E e, F f, G g)
apply
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
a
- the first argumentb
- the second argumentc
- the third argumentd
- the fourth argumente
- the fifth argumentf
- the sixth argumentg
- the seventh argumentFn1
that takes the remaining argument and returns the resultdefault Fn8<B,A,C,D,E,F,G,H,I> flip()
flip
in interface Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>
flip
in interface Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>
flip
in interface Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>
flip
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
flip
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
flip
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
Fn8
that takes the first and second arguments in reversed orderdefault Fn7<? super Product2<? extends A,? extends B>,C,D,E,F,G,H,I> uncurry()
uncurry
in interface Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>
uncurry
in interface Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>
uncurry
in interface Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>
uncurry
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
uncurry
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
uncurry
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
Fn7
taking a Product2
and the remaining argumentsdefault <J> Fn8<A,B,C,D,E,F,G,H,I> discardR(Applicative<J,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,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>
discardR
in interface Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>>
discardR
in interface Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>
discardR
in interface Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>
discardR
in interface Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>
discardR
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
discardR
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
discardR
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
discardR
in interface Monad<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>
discardR
in interface MonadReader<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>
discardR
in interface MonadRec<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>
discardR
in interface MonadWriter<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>
J
- the type of appB's parameterappB
- the other Applicativedefault <Z> Fn8<Z,B,C,D,E,F,G,H,I> diMapL(Fn1<? super Z,? extends A> fn)
Fn2
diMapL
in interface Cartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>
diMapL
in interface Cocartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>
diMapL
in interface Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>>
diMapL
in interface Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>
diMapL
in interface Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>
diMapL
in interface Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>
diMapL
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
diMapL
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
diMapL
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
diMapL
in interface Profunctor<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>
Z
- the new argument typefn
- the contravariant argument mapping functionFn1
<Z, B>default <Z> Fn8<Z,B,C,D,E,F,G,H,I> contraMap(Fn1<? super Z,? extends A> fn)
Fn2
A <- B
.contraMap
in interface Cartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>
contraMap
in interface Cocartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>
contraMap
in interface Contravariant<A,Profunctor<?,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>>
contraMap
in interface Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>>
contraMap
in interface Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>
contraMap
in interface Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>
contraMap
in interface Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>
contraMap
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
contraMap
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
contraMap
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
contraMap
in interface Profunctor<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>
Z
- the new parameter typefn
- the mapping functiondefault <Y,Z> Fn8<Y,Z,B,C,D,E,F,G,Fn1<H,I>> compose(Fn2<? super Y,? super Z,? extends A> before)
Fn2
compose
in interface Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>>
compose
in interface Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>
compose
in interface Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>
compose
in interface Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>
compose
in interface Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>
compose
in interface Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>
compose
in interface Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
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,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn1<A,Fn7<B,C,D,E,F,G,H,I>> curriedFn1)
A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the fifth input argument typeF
- the sixth input argument typeG
- the seventh input argument typeH
- the eighth input argument typeI
- the output typecurriedFn1
- the curried fn1 to adaptFn8
static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn2<A,B,Fn6<C,D,E,F,G,H,I>> curriedFn2)
A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the fifth input argument typeF
- the sixth input argument typeG
- the seventh input argument typeH
- the eighth input argument typeI
- the output typecurriedFn2
- the curried fn2 to adaptFn8
static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn3<A,B,C,Fn5<D,E,F,G,H,I>> curriedFn3)
A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the fifth input argument typeF
- the sixth input argument typeG
- the seventh input argument typeH
- the eighth input argument typeI
- the output typecurriedFn3
- the curried fn3 to adaptFn8
static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn4<A,B,C,D,Fn4<E,F,G,H,I>> curriedFn4)
A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the fifth input argument typeF
- the sixth input argument typeG
- the seventh input argument typeH
- the eighth input argument typeI
- the output typecurriedFn4
- the curried fn4 to adaptFn8
static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn5<A,B,C,D,E,Fn3<F,G,H,I>> curriedFn5)
A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the fifth input argument typeF
- the sixth input argument typeG
- the seventh input argument typeH
- the eighth input argument typeI
- the output typecurriedFn5
- the curried fn4 to adaptFn8
static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn6<A,B,C,D,E,F,Fn2<G,H,I>> curriedFn6)
A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the fifth input argument typeF
- the sixth input argument typeG
- the seventh input argument typeH
- the eighth input argument typeI
- the output typecurriedFn6
- the curried fn4 to adaptFn8
static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn7<A,B,C,D,E,F,G,Fn1<H,I>> curriedFn7)
A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the fifth input argument typeF
- the sixth input argument typeG
- the seventh input argument typeH
- the eighth input argument typeI
- the output typecurriedFn7
- the curried fn4 to adaptFn8
static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn8<A,B,C,D,E,F,G,H,I> fn)
Fn8
.A
- the first input argument typeB
- the second input argument typeC
- the third input argument typeD
- the fourth input argument typeE
- the fifth input argument typeF
- the sixth input argument typeG
- the seventh input argument typeH
- the eighth input argument typeI
- the output typefn
- the lambda to coerceFn8