Uses of Interface
com.jnape.palatable.lambda.functions.Fn3

Packages that use Fn3

Package	Description
com.jnape.palatable.lambda.adt.product
com.jnape.palatable.lambda.functions
com.jnape.palatable.lambda.functions.builtin.fn2
com.jnape.palatable.lambda.functions.builtin.fn3
com.jnape.palatable.lambda.functions.builtin.fn4
com.jnape.palatable.lambda.functions.builtin.fn5
com.jnape.palatable.lambda.functions.builtin.fn6
com.jnape.palatable.lambda.functions.builtin.fn7
com.jnape.palatable.lambda.functions.builtin.fn8
com.jnape.palatable.lambda.functions.specialized
com.jnape.palatable.lambda.monoid.builtin
com.jnape.palatable.lambda.optics.functions
com.jnape.palatable.lambda.semigroup.builtin

Uses of Fn3 in com.jnape.palatable.lambda.adt.product

Methods in com.jnape.palatable.lambda.adt.product with parameters of type Fn3

Modifier and Type	Method	Description
default <R> R	Product3.into(Fn3<? super _1, ? super _2, ? super _3, ? extends R> fn)	Destructure and apply this product to a function accepting the same number of arguments as this product's slots.

Uses of Fn3 in com.jnape.palatable.lambda.functions

Subinterfaces of Fn3 in com.jnape.palatable.lambda.functions

Modifier and Type	Interface	Description
interface	Fn4<A,B,C,D,E>	A function taking four arguments.
interface	Fn5<A,B,C,D,E,F>	A function taking five arguments.
interface	Fn6<A,B,C,D,E,F,G>	A function taking six arguments.
interface	Fn7<A,B,C,D,E,F,G,H>	A function taking seven arguments.
interface	Fn8<A,B,C,D,E,F,G,H,I>	A function taking eight arguments.

Methods in com.jnape.palatable.lambda.functions that return Fn3

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

Methods in com.jnape.palatable.lambda.functions with parameters of type Fn3

Modifier and Type	Method	Description
static <A,B,C,D> Fn3<A,B,C,D>	Fn3.fn3(Fn3<A,B,C,D> fn)	Static factory method for coercing a lambda to an Fn3.
static <A,B,C,D,E> Fn4<A,B,C,D,E>	Fn4.fn4(Fn3<A,B,C,Fn1<D,E>> curriedFn3)	Static factory method for wrapping a curried Fn3 in an Fn4.
static <A,B,C,D,E,F> Fn5<A,B,C,D,E,F>	Fn5.fn5(Fn3<A, B, C, Fn2<D,E,F>> curriedFn3)	Static factory method for wrapping a curried Fn3 in an Fn5.
static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>	Fn6.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,H> Fn7<A,B,C,D,E,F,G,H>	Fn7.fn7(Fn3<A, B, C, Fn4<D,E,F,G,H>> curriedFn3)	Static factory method for wrapping a curried Fn3 in an Fn7.
static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I>	Fn8.fn8(Fn3<A, B, C, Fn5<D,E,F,G,H,I>> curriedFn3)	Static factory method for wrapping a curried Fn3 in an Fn8.

Method parameters in com.jnape.palatable.lambda.functions with type arguments of type Fn3

Modifier and Type	Method	Description
static <A,B,C,D,E> Fn4<A,B,C,D,E>	Fn4.fn4(Fn1<A, Fn3<B,C,D,E>> curriedFn1)	Static factory method for wrapping a curried Fn1 in an Fn4.
static <A,B,C,D,E,F> Fn5<A,B,C,D,E,F>	Fn5.fn5(Fn2<A, B, Fn3<C,D,E,F>> curriedFn2)	Static factory method for wrapping a curried Fn2 in an Fn5.
static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>	Fn6.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,H> Fn7<A,B,C,D,E,F,G,H>	Fn7.fn7(Fn4<A, B, C, D, Fn3<E,F,G,H>> curriedFn4)	Static factory method for wrapping a curried Fn4 in an Fn7.
static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I>	Fn8.fn8(Fn5<A, B, C, D, E, Fn3<F,G,H,I>> curriedFn5)	Static factory method for wrapping a curried Fn5 in an Fn8.

Uses of Fn3 in com.jnape.palatable.lambda.functions.builtin.fn2

Classes in com.jnape.palatable.lambda.functions.builtin.fn2 that implement Fn3

Modifier and Type	Class	Description
final class	Both<A,B,C>	Given two functions f and g, produce a Fn1<A, Tuple2<B, C>> (the dual application of both functions).
final class	Peek2<A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>>	Deprecated. in favor of producing an IO from the given BoundedBifunctor and explicitly running it

Classes in com.jnape.palatable.lambda.functions.builtin.fn2 that implement interfaces with type arguments of type Fn3

Modifier and Type	Class	Description
final class	Into3<A,B,C,D>	Given an Fn3<A, B, C, D> and a Product3<A, B, C>, destructure the product and apply the slots as arguments to the function, returning the result.

Methods in com.jnape.palatable.lambda.functions.builtin.fn2 with parameters of type Fn3

Modifier and Type	Method	Description
D	Into3.checkedApply(Fn3<? super A, ? super B, ? super C, ? extends D> fn, Product3<A,B,C> product)
static <A,B,C,D> Fn1<Product3<A,B,C>, D>	Into3.into3(Fn3<? super A, ? super B, ? super C, ? extends D> fn)
static <A,B,C,D> D	Into3.into3(Fn3<? super A, ? super B, ? super C, ? extends D> fn, Product3<A,B,C> product)

Uses of Fn3 in com.jnape.palatable.lambda.functions.builtin.fn3

Classes in com.jnape.palatable.lambda.functions.builtin.fn3 that implement Fn3

Modifier and Type	Class	Description
final class	Between<A extends Comparable<A>>	Given two bounds and a value, return whether or not the value is greater than or equal to the lower bound and less than or equal to the upper bound.
final class	Bracket<A,B>	Given an IO that yields some type A, a cleanup operation to run if a value of that type could be provisioned, and a kleisli arrow from that type to a new IO of type B, produce an IO<B> that, when run, will provision the A, flatMap it to B, and clean up the original value if it was produced in the first place.
final class	Clamp<A extends Comparable<A>>	Given two bounds and a value, "clamp" the value between the bounds via the following algorithm: - if the value is strictly less than the lower bound, return the lower bound - if the value is strictly greater than the upper bound, return the upper bound - otherwise, return the value
final class	CmpEqBy<A, B extends Comparable<B>>	Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the first value is strictly equal to the second value (according to Comparable.compareTo(Object) in terms of their mapped B results; otherwise, return false.
final class	CmpEqWith<A>	Given a Comparator from some type A and two values of type A, return true if the first value is strictly equal to the second value (according to Comparator.compare(Object, Object) otherwise, return false.
final class	Compare<A>	Given a Comparator from some type A and two values of type A, return a ComparisonRelation of the first value with reference to the second value (according to Comparator.compare(Object, Object).
final class	FoldLeft<A,B>	Given an Iterable of As, a starting value B, and a Fn2<B, A, B>, iteratively accumulate over the Iterable, ultimately returning a final B value.
final class	FoldRight<A,B>	Given an Iterable of As, a starting lazy value B, and a Fn2<A, Lazy<B>, Lazy<B>>, iteratively accumulate over the Iterable, ultimately returning a final Lazy<B> value.
final class	GTBy<A, B extends Comparable<B>>	Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is strictly greater than the first value in terms of their mapped B results; otherwise, return false.
final class	GTEBy<A, B extends Comparable<B>>	Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is greater than or equal to the first value in terms of their mapped B results according to Comparable.compareTo(Object); otherwise, return false.
final class	GTEWith<A>	Given a Comparator from some type A and two values of type A, return true if the second value is greater than or equal to the first value in terms of their mapped B results according to Comparator.compare(Object, Object); otherwise, return false.
final class	GTWith<A>	Given a Comparator from some type A and two values of type A, return true if the second value is strictly greater than the first value in terms of their mapped B results; otherwise, return false.
final class	LiftA2<A, B, C, App extends Applicative<?,App>, AppC extends Applicative<C,App>>	Lift into and apply an Fn2 to two Applicative values, returning the result inside the same Applicative context.
final class	LTBy<A, B extends Comparable<B>>	Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is strictly less than the first value in terms of their mapped B results; otherwise, return false.
final class	LTEBy<A, B extends Comparable<B>>	Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is less than or equal to the first value in terms of their mapped B results according to Comparable.compareTo(Object); otherwise, return false.
final class	LTEWith<A>	Given a Comparator from some type A and two values of type A, return true if the second value is less than or equal to the first value in terms of their mapped B results according to Comparator.compare(Object, Object); otherwise, return false.
final class	LTWith<A>	Given a comparator for some type A and two values of type A, return true if the second value is strictly less than than the first value in terms of their mapped B results; otherwise, return false.
final class	ScanLeft<A,B>	Given an Iterable of As, a starting value B, and a Fn2<B, A, B>, iteratively accumulate over the Iterable, collecting each function application result, finally returning an Iterable of all the results.
final class	Times<A>	Given some number of times n to invoke a function A -> A, and given an input A, iteratively apply the function to the input, and then to the result of the invocation, a total of n times, returning the result.
final class	ZipWith<A,B,C>	Zip together two Iterables by applying a zipping function to the successive elements of each Iterable until one of them runs out of elements.

Uses of Fn3 in com.jnape.palatable.lambda.functions.builtin.fn4

Classes in com.jnape.palatable.lambda.functions.builtin.fn4 that implement Fn3

Modifier and Type	Class	Description
final class	IfThenElse<A,B>
final class	LiftA3<A, B, C, D, App extends Applicative<?,App>, AppD extends Applicative<D,App>>	Lift into and apply an Fn3 to three Applicative values, returning the result inside the same Applicative context.
final class	RateLimit<A>	Given an Fn0 of Instants (presumably backed by a clock), a limit, a Duration, and an Iterable as, return an Iterable that iterates as according to the threshold specified by the limit per duration, using the Fn0 to advance time.

Classes in com.jnape.palatable.lambda.functions.builtin.fn4 that implement interfaces with type arguments of type Fn3

Modifier and Type	Class	Description
final class	LiftA3<A, B, C, D, App extends Applicative<?,App>, AppD extends Applicative<D,App>>	Lift into and apply an Fn3 to three Applicative values, returning the result inside the same Applicative context.

Methods in com.jnape.palatable.lambda.functions.builtin.fn4 that return Fn3

Modifier and Type	Method	Description
static <A,B> Fn3<Fn1<? super A, ? extends B>, Fn1<? super A, ? extends B>, A, B>	IfThenElse.ifThenElse(Fn1<? super A, ? extends Boolean> predicate)
static <A, B, C, D, App extends Applicative<?,App>, AppD extends Applicative<D,App>> Fn3<Applicative<A,App>, Applicative<B,App>, Applicative<C,App>, AppD>	LiftA3.liftA3(Fn3<A,B,C,D> fn)
static <A> Fn3<Long, Duration, Iterable<A>, Iterable<A>>	RateLimit.rateLimit(Fn0<Instant> instantFn0)

Methods in com.jnape.palatable.lambda.functions.builtin.fn4 with parameters of type Fn3

Modifier and Type	Method	Description
AppD	LiftA3.checkedApply(Fn3<A,B,C,D> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC)
static <A, B, C, D, App extends Applicative<?,App>, AppD extends Applicative<D,App>> Fn3<Applicative<A,App>, Applicative<B,App>, Applicative<C,App>, AppD>	LiftA3.liftA3(Fn3<A,B,C,D> fn)
static <A, B, C, D, App extends Applicative<?,App>, AppD extends Applicative<D,App>> Fn2<Applicative<B,App>, Applicative<C,App>, AppD>	LiftA3.liftA3(Fn3<A,B,C,D> fn, Applicative<A,App> appA)
static <A, B, C, D, App extends Applicative<?,App>, AppD extends Applicative<D,App>> Fn1<Applicative<C,App>, AppD>	LiftA3.liftA3(Fn3<A,B,C,D> fn, Applicative<A,App> appA, Applicative<B,App> appB)
static <A, B, C, D, App extends Applicative<?,App>, AppD extends Applicative<D,App>> AppD	LiftA3.liftA3(Fn3<A,B,C,D> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC)

Uses of Fn3 in com.jnape.palatable.lambda.functions.builtin.fn5

Classes in com.jnape.palatable.lambda.functions.builtin.fn5 that implement Fn3

Modifier and Type	Class	Description
final class	LiftA4<A, B, C, D, E, App extends Applicative<?,App>, AppE extends Applicative<E,App>>	Lift into and apply an Fn4 to four Applicative values, returning the result inside the same Applicative context.

Methods in com.jnape.palatable.lambda.functions.builtin.fn5 that return Fn3

Modifier and Type	Method	Description
static <A, B, C, D, E, App extends Applicative<?,App>, AppE extends Applicative<E,App>> Fn3<Applicative<B,App>, Applicative<C,App>, Applicative<D,App>, AppE>	LiftA4.liftA4(Fn4<A,B,C,D,E> fn, Applicative<A,App> appA)

Uses of Fn3 in com.jnape.palatable.lambda.functions.builtin.fn6

Classes in com.jnape.palatable.lambda.functions.builtin.fn6 that implement Fn3

Modifier and Type	Class	Description
final class	LiftA5<A, B, C, D, E, F, App extends Applicative<?,App>, AppF extends Applicative<F,App>>	Lift into and apply an Fn5 to five Applicative values, returning the result inside the same Applicative context.

Methods in com.jnape.palatable.lambda.functions.builtin.fn6 that return Fn3

Modifier and Type	Method	Description
static <A, B, C, D, E, F, App extends Applicative<?,App>, AppF extends Applicative<F,App>> Fn3<Applicative<C,App>, Applicative<D,App>, Applicative<E,App>, AppF>	LiftA5.liftA5(Fn5<A,B,C,D,E,F> fn, Applicative<A,App> appA, Applicative<B,App> appB)

Uses of Fn3 in com.jnape.palatable.lambda.functions.builtin.fn7

Classes in com.jnape.palatable.lambda.functions.builtin.fn7 that implement Fn3

Modifier and Type	Class	Description
final class	LiftA6<A, B, C, D, E, F, G, App extends Applicative<?,App>, AppG extends Applicative<G,App>>	Lift into and apply an Fn6 to six Applicative values, returning the result inside the same Applicative context.

Methods in com.jnape.palatable.lambda.functions.builtin.fn7 that return Fn3

Modifier and Type	Method	Description
static <A, B, C, D, E, F, G, App extends Applicative<?,App>, AppG extends Applicative<G,App>> Fn3<Applicative<D,App>, Applicative<E,App>, Applicative<F,App>, AppG>	LiftA6.liftA6(Fn6<A,B,C,D,E,F,G> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC)

Uses of Fn3 in com.jnape.palatable.lambda.functions.builtin.fn8

Classes in com.jnape.palatable.lambda.functions.builtin.fn8 that implement Fn3

Modifier and Type	Class	Description
final class	LiftA7<A, B, C, D, E, F, G, H, App extends Applicative<?,App>, AppH extends Applicative<H,App>>	Lift into and apply an Fn7 to seven Applicative values, returning the result inside the same Applicative context.

Methods in com.jnape.palatable.lambda.functions.builtin.fn8 that return Fn3

Modifier and Type	Method	Description
static <A, B, C, D, E, F, G, H, App extends Applicative<?,App>, AppH extends Applicative<H,App>> Fn3<Applicative<E,App>, Applicative<F,App>, Applicative<G,App>, AppH>	LiftA7.liftA7(Fn7<A,B,C,D,E,F,G,H> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC, Applicative<D,App> appD)

Uses of Fn3 in com.jnape.palatable.lambda.functions.specialized

Subinterfaces of Fn3 in com.jnape.palatable.lambda.functions.specialized

Modifier and Type	Interface	Description
interface	BiMonoidFactory<A,B,C>
interface	BiSemigroupFactory<A,B,C>
interface	MonoidFactory<A,B>
interface	SemigroupFactory<A,B>

Uses of Fn3 in com.jnape.palatable.lambda.monoid.builtin

Classes in com.jnape.palatable.lambda.monoid.builtin that implement Fn3

Modifier and Type	Class	Description
final class	AddAll<A, C extends Collection<A>>	The Monoid instance formed under mutative concatenation for an arbitrary Collection.
final class	Collapse<_1,_2>	A Monoid instance formed by a Tuple2<_1, _2> and monoids over _1 and _2.
final class	Compose<A>	A Monoid instance formed by CompletableFuture<A> and a monoid over A.
final class	EndoK<M extends MonadRec<?,M>, A, MA extends MonadRec<A,M>>	The monoid formed under monadic endomorphism.
final class	LeftAll<L,R>	A Monoid instance formed by Either<L,R> and a monoid over L.
final class	LeftAny<L,R>	A Monoid instance formed by Either<L,R> and a monoid over L.
final class	Merge<L,R>	A Monoid instance formed by Either.merge(Fn2, Fn2, Either...), a semigroup over L, and a monoid over R.
final class	MergeMaps<K,V>	A Monoid instance formed by Map.merge(Object, Object, BiFunction) and a semigroup over V.
final class	Present<A>	A Monoid instance formed by Maybe<A> and a semigroup over A.
final class	RightAll<L,R>	A Monoid instance formed by Either<L,R> and a monoid over R.
final class	RightAny<L,R>	A Monoid instance formed by Either<L,R> and a monoid over R.
final class	RunAll<A>	Run IO operations, aggregating their results in terms of the provided Monoid.

Uses of Fn3 in com.jnape.palatable.lambda.optics.functions

Classes in com.jnape.palatable.lambda.optics.functions that implement Fn3

Modifier and Type	Class	Description
final class	Over<S,T,A,B>	Given an Optic, a function from A to B, and a "larger" value S, produce a T by retrieving the A from the S, applying the function, and updating the S with the B resulting from the function.
final class	Set<S,T,A,B>	Given an Optic, a "smaller" value B, and a "larger" value S, produce a T by lifting the Optic into the Identity functor.
final class	Under<S,T,A,B>	The inverse of Over: given an Iso, a function from T to S, and a "smaller" value B, return a "smaller" value A by traversing around the type ring (B -> T -> S -> A).

Uses of Fn3 in com.jnape.palatable.lambda.semigroup.builtin

Classes in com.jnape.palatable.lambda.semigroup.builtin that implement Fn3

Modifier and Type	Class	Description
final class	Absent<A>	A Semigroup instance formed by Maybe<A> and a semigroup over A.
final class	Collapse<_1,_2>	A Semigroup instance formed by a Tuple2<_1, _2> and semigroups over _1 and _2.
final class	Compose<A>	A Semigroup instance formed by CompletableFuture<A> and a semigroup over A.
final class	LeftAll<L,R>	A Semigroup instance formed by Either<L,R> and a semigroup over L.
final class	LeftAny<L,R>	A Semigroup instance formed by Either<L,R> and a semigroup over L.
final class	MaxBy<A, B extends Comparable<B>>	Given a mapping function from some type A to some Comparable type B, produce a Semigroup over A that chooses between two values x and y via the following rules: If x is strictly less than y in terms of B, return y Otherwise, return x
final class	MaxWith<A>	Given a comparator for some type A, produce a Semigroup over A that chooses between two values x and y via the following rules: If x is strictly less than y in terms of B, return y Otherwise, return x
final class	Merge<L,R>	A Semigroup instance formed by Either.merge(Fn2, Fn2, Either...) and semigroups over L and R.
final class	MinBy<A, B extends Comparable<B>>	Given a mapping function from some type A to some Comparable type B, produce a Semigroup over A that chooses between two values x and y via the following rules: If x is strictly greater than y in terms of B, return y Otherwise, return x
final class	MinWith<A>	Given a comparator for some type A, produce a Semigroup over A that chooses between two values x and y via the following rules: If x is strictly greater than y in terms of B, return y Otherwise, return x
final class	RightAll<L,R>	A Semigroup instance formed by Either<L,R> and a semigroup over R.
final class	RightAny<L,R>	A Semigroup instance formed by Either<L,R> and a semigroup over R.
final class	RunAll<A>	Run IO operations, aggregating their results in terms of the provided Semigroup.