Package com.jnape.palatable.lambda.functions

Interface Fn6<A,B,C,D,E,F,G>

Type Parameters:

A - The first argument type

B - The second argument type

C - The third argument type

D - The fourth argument type

E - The fifth argument type

F - The sixth argument type

G - The return type

All Superinterfaces:

Applicative<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>,Fn1<A,?>>, Cartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>,Fn1<?,?>>, Cocartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>,Fn1<?,?>>, Contravariant<A,Profunctor<?,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>,Fn1<?,?>>>, Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>>, Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>, Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,G>>>>, Fn4<A,B,C,D,Fn1<E,Fn1<F,G>>>, Fn5<A,B,C,D,E,Fn1<F,G>>, Functor<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>,Fn1<A,?>>, Monad<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>,Fn1<A,?>>, MonadReader<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>,Fn1<A,?>>, MonadRec<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>,Fn1<A,?>>, MonadWriter<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>,Fn1<A,?>>, Profunctor<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,G>>>>>,Fn1<?,?>>

All Known Subinterfaces:

Fn7<A,B,C,D,E,F,G,H>, Fn8<A,B,C,D,E,F,G,H,I>

All Known Implementing Classes:

LiftA5, LiftA6, LiftA7

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface Fn6<A,B,C,D,E,F,G>
extends Fn5<A,B,C,D,E,Fn1<F,G>>

A function taking six arguments. Defined in terms of Fn5, so similarly auto-curried.

See Also:

Fn5

Method Summary

Modifier and Type	Method	Description
default Fn5<B,C,D,E,F,G>	apply(A a)	Partially apply this function by taking its first argument.
default Fn4<C,D,E,F,G>	apply(A a, B b)	Partially apply this function by taking its first two arguments.
default Fn3<D,E,F,G>	apply(A a, B b, C c)	Partially apply this function by taking its first three arguments.
default Fn2<E,F,G>	apply(A a, B b, C c, D d)	Partially apply this function by taking its first four arguments.
default Fn1<F,G>	apply(A a, B b, C c, D d, E e)	Partially apply this function by taking its first five arguments.
default G	apply(A a, B b, C c, D d, E e, F f)	Invoke this function with the given arguments.
default Fn1<F,G>	checkedApply(A a, B b, C c, D d, E e)
G	checkedApply(A a, B b, C c, D d, E e, F f)
default <Y,Z> Fn7<Y,Z,B,C,D,E,F,G>	compose(Fn2<? super Y,? super Z,? extends A> before)	Right-to-left composition between different arity functions.
default <Z> Fn6<Z,B,C,D,E,F,G>	contraMap(Fn1<? super Z,? extends A> fn)	Contravariantly map A <- B.
default <Z> Fn6<Z,B,C,D,E,F,G>	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 <H> Fn6<A,B,C,D,E,F,G>	discardR(Applicative<H,Fn1<A,?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
default Fn6<B,A,C,D,E,F,G>	flip()	Flip the order of the first two arguments.
static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>	fn6(Fn1<A,Fn5<B,C,D,E,F,G>> curriedFn1)	Static factory method for wrapping a curried Fn1 in an Fn6.
static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>	fn6(Fn2<A,B,Fn4<C,D,E,F,G>> curriedFn2)	Static factory method for wrapping a curried Fn2 in an Fn6.
static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>	fn6(Fn3<A,B,C,Fn3<D,E,F,G>> curriedFn3)	Static factory method for wrapping a curried Fn3 in an Fn6.
static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>	fn6(Fn4<A,B,C,D,Fn2<E,F,G>> curriedFn4)	Static factory method for wrapping a curried Fn4 in an Fn6.
static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>	fn6(Fn5<A,B,C,D,E,Fn1<F,G>> curriedFn5)	Static factory method for wrapping a curried Fn5 in an Fn6.
static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>	fn6(Fn6<A,B,C,D,E,F,G> fn)	Static factory method for coercing a lambda to an Fn6.
default Fn5<? super Product2<? extends A,? extends B>,C,D,E,F,G>	uncurry()	Returns an Fn5 that takes the first two arguments as a Product2<A, B> and the remaining arguments.
default <Z> Fn7<Z,A,B,C,D,E,F,G>	widen()	Widen this function's argument list by prepending an ignored argument of any type to the front.

Methods inherited from interface com.jnape.palatable.lambda.functions.Fn1

andThen, carry, cartesian, censor, choose, cocartesian, diMap, diMapR, discardL, flatMap, fmap, lazyZip, listens, local, pure, self, thunk, toFunction, trampolineM, zip, zip

Methods inherited from interface com.jnape.palatable.lambda.functions.Fn2

checkedApply, toBiFunction

Methods inherited from interface com.jnape.palatable.lambda.functions.Fn3

checkedApply

Methods inherited from interface com.jnape.palatable.lambda.functions.Fn4

checkedApply

Methods inherited from interface com.jnape.palatable.lambda.functions.Fn5

checkedApply

Methods inherited from interface com.jnape.palatable.lambda.functor.Functor

coerce

Method Detail

checkedApply

G checkedApply(A a,
               B b,
               C c,
               D d,
               E e,
               F f)
        throws java.lang.Throwable

Throws:

java.lang.Throwable

apply

default G apply(A a,
                B b,
                C c,
                D d,
                E e,
                F f)

Invoke this function with the given arguments.

Parameters:

a - the first argument

b - the second argument

c - the third argument

d - the fourth argument

e - the fifth argument

f - the sixth argument

Returns:

the result of the function application

checkedApply

default Fn1<F,G> checkedApply(A a,
                                    B b,
                                    C c,
                                    D d,
                                    E e)
                             throws java.lang.Throwable

Specified by:

checkedApply in interface Fn5<A,B,C,D,E,F>

Throws:

java.lang.Throwable

widen

default <Z> Fn7<Z,A,B,C,D,E,F,G> 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>

Specified by:

widen in interface Fn3<A,B,C,D>

Specified by:

widen in interface Fn4<A,B,C,D,E>

Specified by:

widen in interface Fn5<A,B,C,D,E,F>

Type Parameters:

Z - the new first argument type

Returns:

the widened function

apply

default Fn5<B,C,D,E,F,G> 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>

Specified by:

apply in interface Fn3<A,B,C,D>

Specified by:

apply in interface Fn4<A,B,C,D,E>

Specified by:

apply in interface Fn5<A,B,C,D,E,F>

Parameters:

a - the first argument

Returns:

an Fn5 that takes the remaining arguments and returns the result

apply

default Fn4<C,D,E,F,G> apply(A a,
                                                     B b)

Partially apply this function by taking its first two arguments.

Specified by:

apply in interface Fn2<A,B,C>

Specified by:

apply in interface Fn3<A,B,C,D>

Specified by:

apply in interface Fn4<A,B,C,D,E>

Specified by:

apply in interface Fn5<A,B,C,D,E,F>

Parameters:

a - the first argument

b - the second argument

Returns:

an Fn4 that takes the remaining arguments and returns the result

apply

default Fn3<D,E,F,G> apply(A a,
                                             B b,
                                             C c)

Partially apply this function by taking its first three arguments.

Specified by:

apply in interface Fn3<A,B,C,D>

Specified by:

apply in interface Fn4<A,B,C,D,E>

Specified by:

apply in interface Fn5<A,B,C,D,E,F>

Parameters:

a - the first argument

b - the second argument

c - the third argument

Returns:

an Fn3 that takes remaining arguments and returns the result

apply

default Fn2<E,F,G> apply(A a,
                                     B b,
                                     C c,
                                     D d)

Partially apply this function by taking its first four arguments.

Specified by:

apply in interface Fn4<A,B,C,D,E>

Specified by:

apply in interface Fn5<A,B,C,D,E,F>

Parameters:

a - the first argument

b - the second argument

c - the third argument

d - the fourth argument

Returns:

an Fn2 that takes the remaining arguments and returns the result

apply

default Fn1<F,G> apply(A a,
                             B b,
                             C c,
                             D d,
                             E e)

Partially apply this function by taking its first five arguments.

Specified by:

apply in interface Fn5<A,B,C,D,E,F>

Parameters:

a - the first argument

b - the second argument

c - the third argument

d - the fourth argument

e - the fifth argument

Returns:

an Fn1 that takes the remaining argument and returns the result

flip

default Fn6<B,A,C,D,E,F,G> flip()

Flip the order of the first two arguments.

Specified by:

flip in interface Fn2<A,B,C>

Specified by:

flip in interface Fn3<A,B,C,D>

Specified by:

flip in interface Fn4<A,B,C,D,E>

Specified by:

flip in interface Fn5<A,B,C,D,E,F>

Returns:

an Fn6 that takes the first and second arguments in reversed order

uncurry

default Fn5<? super Product2<? extends A,? extends B>,C,D,E,F,G> uncurry()

Returns an Fn5 that takes the first two arguments as a Product2<A, B> and the remaining arguments.

Specified by:

uncurry in interface Fn2<A,B,C>

Specified by:

uncurry in interface Fn3<A,B,C,D>

Specified by:

uncurry in interface Fn4<A,B,C,D,E>

Specified by:

uncurry in interface Fn5<A,B,C,D,E,F>

Returns:

an Fn5 taking a Product2 and the remaining arguments

discardR

default <H> Fn6<A,B,C,D,E,F,G> discardR(Applicative<H,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 Fn3<A,B,C,D>

Specified by:

discardR in interface Fn4<A,B,C,D,E>

Specified by:

discardR in interface Fn5<A,B,C,D,E,F>

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:

H - the type of appB's parameter

Parameters:

appB - the other Applicative

Returns:

this Applicative

diMapL

default <Z> Fn6<Z,B,C,D,E,F,G> 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 Fn3<A,B,C,D>

Specified by:

diMapL in interface Fn4<A,B,C,D,E>

Specified by:

diMapL in interface Fn5<A,B,C,D,E,F>

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>

contraMap

default <Z> Fn6<Z,B,C,D,E,F,G> contraMap(Fn1<? super Z,? extends A> fn)

Description copied from interface: Fn2

Contravariantly map A <- B.

Specified by:

contraMap in interface Cartesian<A,B,C>

Specified by:

contraMap in interface Cocartesian<A,B,C>

Specified by:

contraMap in interface Contravariant<A,B>

Specified by:

contraMap in interface Fn1<A,B>

Specified by:

contraMap in interface Fn2<A,B,C>

Specified by:

contraMap in interface Fn3<A,B,C,D>

Specified by:

contraMap in interface Fn4<A,B,C,D,E>

Specified by:

contraMap in interface Fn5<A,B,C,D,E,F>

Specified by:

contraMap in interface Profunctor<A,B,C>

Type Parameters:

Z - the new parameter type

Parameters:

fn - the mapping function

Returns:

the mapped Contravariant functor instance

compose

default <Y,Z> Fn7<Y,Z,B,C,D,E,F,G> 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>

Specified by:

compose in interface Fn3<A,B,C,D>

Specified by:

compose in interface Fn4<A,B,C,D,E>

Specified by:

compose in interface Fn5<A,B,C,D,E,F>

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>

fn6

static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G> fn6(Fn1<A,Fn5<B,C,D,E,F,G>> curriedFn1)

Static factory method for wrapping a curried Fn1 in an Fn6.

Type Parameters:

A - the first input argument type

B - the second input argument type

C - the third input argument type

D - the fourth input argument type

E - the fifth input argument type

F - the sixth input argument type

G - the output type

Parameters:

curriedFn1 - the curried fn1 to adapt

Returns:

the Fn6

fn6

static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G> fn6(Fn2<A,B,Fn4<C,D,E,F,G>> curriedFn2)

Static factory method for wrapping a curried Fn2 in an Fn6.

Type Parameters:

A - the first input argument type

B - the second input argument type

C - the third input argument type

D - the fourth input argument type

E - the fifth input argument type

F - the sixth input argument type

G - the output type

Parameters:

curriedFn2 - the curried fn2 to adapt

Returns:

the Fn6

fn6

static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G> fn6(Fn3<A,B,C,Fn3<D,E,F,G>> curriedFn3)

Static factory method for wrapping a curried Fn3 in an Fn6.

Type Parameters:

A - the first input argument type

B - the second input argument type

C - the third input argument type

D - the fourth input argument type

E - the fifth input argument type

F - the sixth input argument type

G - the output type

Parameters:

curriedFn3 - the curried fn3 to adapt

Returns:

the Fn6

fn6

static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G> fn6(Fn4<A,B,C,D,Fn2<E,F,G>> curriedFn4)

Static factory method for wrapping a curried Fn4 in an Fn6.

Type Parameters:

A - the first input argument type

B - the second input argument type

C - the third input argument type

D - the fourth input argument type

E - the fifth input argument type

F - the sixth input argument type

G - the output type

Parameters:

curriedFn4 - the curried fn4 to adapt

Returns:

the Fn6

fn6

static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G> fn6(Fn5<A,B,C,D,E,Fn1<F,G>> curriedFn5)

Static factory method for wrapping a curried Fn5 in an Fn6.

Type Parameters:

A - the first input argument type

B - the second input argument type

C - the third input argument type

D - the fourth input argument type

E - the fifth input argument type

F - the sixth input argument type

G - the output type

Parameters:

curriedFn5 - the curried fn4 to adapt

Returns:

the Fn6

fn6

static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G> fn6(Fn6<A,B,C,D,E,F,G> fn)

Static factory method for coercing a lambda to an Fn6.

Type Parameters:

A - the first input argument type

B - the second input argument type

C - the third input argument type

D - the fourth input argument type

E - the fifth input argument type

F - the sixth input argument type

G - the output type

Parameters:

fn - the lambda to coerce

Returns:

the Fn6