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

Packages that use Fn2

Package	Description
com.jnape.palatable.lambda.adt
com.jnape.palatable.lambda.adt.product
com.jnape.palatable.lambda.functions
com.jnape.palatable.lambda.functions.builtin.fn1
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.recursion
com.jnape.palatable.lambda.functions.specialized
com.jnape.palatable.lambda.internal.iteration
com.jnape.palatable.lambda.monad.transformer.builtin
com.jnape.palatable.lambda.monoid
com.jnape.palatable.lambda.monoid.builtin
com.jnape.palatable.lambda.optics
com.jnape.palatable.lambda.optics.functions
com.jnape.palatable.lambda.semigroup
com.jnape.palatable.lambda.semigroup.builtin

Uses of Fn2 in com.jnape.palatable.lambda.adt

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

Modifier and Type	Method	Description
final Either<L,R>	Either.merge(Fn2<? super L,? super L,? extends L> leftFn, Fn2<? super R,? super R,? extends R> rightFn, Either<L,R>... others)	Given two binary operators over L and R, merge multiple Either<L, R>s into a single Either<L, R>.

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

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

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

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

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

Modifier and Type	Interface	Description
interface	Fn3<A,B,C,D>	A function taking three arguments.
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 Fn2

Modifier and Type	Method	Description
default <C, D> Fn2<A,C,D>	Fn1.andThen(Fn2<? super B,? super C,? extends D> after)	Left-to-right composition between different arity functions.
default Fn2<B,C,D>	Fn3.apply(A a)	Partially apply this function by taking its first argument.
default Fn2<C,D,E>	Fn4.apply(A a, B b)	Partially apply this function by taking its first two arguments.
default Fn2<D,E,F>	Fn5.apply(A a, B b, C c)	Partially apply this function by taking its first three arguments.
default Fn2<E,F,G>	Fn6.apply(A a, B b, C c, D d)	Partially apply this function by taking its first four arguments.
default Fn2<F,G,H>	Fn7.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>	Fn8.apply(A a, B b, C c, D d, E e, F f)	Partially apply this function by taking its first six arguments.
default <Y, Z> Fn2<Y,Z,B>	Fn1.compose(Fn2<? super Y,? super Z,? extends A> before)	Right-to-left composition between different arity functions.
default <Z> Fn2<Z,B,C>	Fn2.contraMap(Fn1<? super Z,? extends A> fn)	Contravariantly map A <- B.
static <A, B, C> Fn2<A,B,C>	Fn2.curried(Fn1<A,Fn1<B,C>> curriedFn1)	Static factory method for wrapping a curried Fn1 in an Fn2.
static <A, B, C> Fn2<A,B,C>	Fn2.curry(Fn1<? super Tuple2<A,B>,? extends C> uncurriedFn1)	Static factory method for wrapping an uncurried Fn1 in an Fn2.
default <Z> Fn2<Z,B,C>	Fn2.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 <D> Fn2<A,B,C>	Fn2.discardR(Applicative<D,Fn1<A,?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
default Fn2<B,A,C>	Fn2.flip()	Flip the order of the arguments.
static <A, B, C> Fn2<A,B,C>	Fn2.fn2(Fn2<A,B,C> fn2)	Static method to aid inference.
static <A, B, C> Fn2<A,B,C>	Fn2.fromBiFunction(BiFunction<? super A,? super B,? extends C> biFunction)	Static factory method for wrapping a BiFunction in an Fn2.
default Fn2<? super Product2<? extends A,? extends B>,C,D>	Fn3.uncurry()	Returns an Fn2 that takes the first two arguments as a Product2<A, B> and the third argument.
default <Z> Fn2<Z,A,B>	Fn1.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 Fn2

Modifier and Type	Method	Description
default <C, D> Fn2<A,C,D>	Fn1.andThen(Fn2<? super B,? super C,? extends D> after)	Left-to-right composition between different arity functions.
default <Y, Z> Fn2<Y,Z,B>	Fn1.compose(Fn2<? super Y,? super Z,? extends A> before)	Right-to-left composition between different arity functions.
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 <Y, Z> Fn4<Y,Z,B,C,D>	Fn3.compose(Fn2<? super Y,? super Z,? extends A> before)
default <Y, Z> Fn5<Y,Z,B,C,D,E>	Fn4.compose(Fn2<? super Y,? super Z,? extends A> before)
default <Y, Z> Fn6<Y,Z,B,C,D,E,F>	Fn5.compose(Fn2<? super Y,? super Z,? extends A> before)
default <Y, Z> Fn7<Y,Z,B,C,D,E,F,G>	Fn6.compose(Fn2<? super Y,? super Z,? extends A> before)
default <Y, Z> Fn8<Y,Z,B,C,D,E,F,G,H>	Fn7.compose(Fn2<? super Y,? super Z,? extends A> before)
default <Y, Z> Fn8<Y,Z,B,C,D,E,F,G,Fn1<H,I>>	Fn8.compose(Fn2<? super Y,? super Z,? extends A> before)
static <A, B, C> Fn2<A,B,C>	Fn2.fn2(Fn2<A,B,C> fn2)	Static method to aid inference.
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, E> Fn4<A,B,C,D,E>	Fn4.fn4(Fn2<A,B,Fn2<C,D,E>> curriedFn2)	Static factory method for wrapping a curried Fn2 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(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, H> Fn7<A,B,C,D,E,F,G,H>	Fn7.fn7(Fn2<A,B,Fn5<C,D,E,F,G,H>> curriedFn2)	Static factory method for wrapping a curried Fn2 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(Fn2<A,B,Fn6<C,D,E,F,G,H,I>> curriedFn2)	Static factory method for wrapping a curried Fn2 in an Fn8.
static <A, B> Fn1<A,B>	Fn1.withSelf(Fn2<? super Fn1<? super A,? extends B>,? super A,? extends B> fn)	Construct an Fn1 that has a reference to itself in scope at the time it is executed (presumably for recursive invocations).
default <B> Fn0<B>	Fn0.zip(Fn2<Unit,A,B> appFn)
default <C> Fn1<A,C>	Fn1.zip(Fn2<A,B,C> appFn)

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

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

Uses of Fn2 in com.jnape.palatable.lambda.functions.builtin.fn1

Classes in com.jnape.palatable.lambda.functions.builtin.fn1 that implement Fn2

Modifier and Type	Class	Description
final class	Constantly<A,B>	A function that takes two arguments and always returns the first argument.
final class	Not<A>	Negate a predicate function.

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

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

Modifier and Type	Class	Description
final class	$<A,B>	Function application, represented as a higher-order Fn2 that receives an Fn1 and its argument, and applies it.
final class	All<A>	Eagerly apply a predicate to each element in an Iterable, returning true if every element satisfies the predicate, and false otherwise.
final class	Alter<A>	Given an Effect<A> and some A, produce an IO that, when run, performs the effect on A and returns it.
final class	Any<A>	Eagerly apply a predicate to each element in an Iterable, returning true if any element satisfies the predicate, and false otherwise.
final class	AutoBracket<A extends AutoCloseable,B>	Given an IO yielding some AutoCloseable type A and a kleisli arrow from that type to a new IO of type B, attempt to provision the A, applying the body operation if provisioning was successful and ensuring that AutoCloseable.close() is called regardless of whether the body succeeds or fails.
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	CartesianProduct<A,B>	Lazily compute the cartesian product of an Iterable<A> and Iterable<B>, returning an Iterable<Tuple2<A, B>>, the products as tuples of multiplicand As and multiplier Bs.
final class	CmpEq<A extends Comparable<A>>	Given two Comparable values of type A, return true if the first value is strictly equal to the second value (according to Comparable.compareTo(Object); otherwise, return false.
final class	Cons<A>	Prepend an element to an Iterable.
final class	Difference<A>	Given two Iterables xs and ys, return the distinct elements of xs that are not in ys.
final class	Drop<A>	Lazily skip the first n elements from an Iterable by returning an Iterable that begins iteration after the nth element.
final class	DropWhile<A>	Lazily limit the Iterable by skipping the first contiguous group of elements that satisfy the predicate, beginning iteration at the first element for which the predicate evaluates to false.
final class	Eq<A>	Type-safe equality in function form; uses Object.equals(java.lang.Object), not ==.
final class	Filter<A>	Lazily apply a predicate to each element in an Iterable, returning an Iterable of just the elements for which the predicate evaluated to true.
final class	Find<A>	Iterate the elements in an Iterable, applying a predicate to each one, returning the first element that matches the predicate, wrapped in a Maybe.
final class	GroupBy<K,V>	Given an Iterable<V> vs and a key function V -> K f, fold vs into a Map<K, List<V>> by applying f to each element of vs, retaining values that map to the same key in a list, in the order they were iterated in.
final class	GT<A extends Comparable<A>>	Given two Comparable values of type A, return true if the second value is strictly greater than the first value; otherwise, return false.
final class	GTE<A extends Comparable<A>>	Given two Comparable values of type A, return true if the second value is greater than or equal to the first value according to Comparable.compareTo(Object); otherwise, return false.
final class	InGroupsOf<A>	Lazily group the Iterable by returning an Iterable of smaller Iterables of size k.
final class	Intersperse<A>	Lazily inject the provided separator value between each value in the supplied Iterable.
final class	Into<A,B,C>	Given an Fn2<A, B, C> and a Map.Entry<A, B>, destructure the entry and apply the key and value as arguments to the function, returning the result.
final class	Into1<A,B>	Given an Fn1<A, B> and a SingletonHList<A>, pop the head and apply it to the function, returning the result.
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.
final class	Into4<A,B,C,D,E>	Given an Fn4<A, B, C, D, E> and a Product4<A, B, C, D>, destructure the product and apply the slots as arguments to the function, returning the result.
final class	Into5<A,B,C,D,E,F>	Given an Fn5<A, B, C, D, E, F> and a Product5<A, B, C, D, E>, destructure the product and apply the slots as arguments to the function, returning the result.
final class	Into6<A,B,C,D,E,F,G>	Given an Fn6<A, B, C, D, E, F, G> and a Product6<A, B, C, D, E, F>, destructure the product and apply the slots as arguments to the function, returning the result.
final class	Into7<A,B,C,D,E,F,G,H>	Given an Fn7<A, B, C, D, E, F, G, H> and a Product7<A, B, C, D, E, F, G>, destructure the product and apply the slots as arguments to the function, returning the result.
final class	Into8<A,B,C,D,E,F,G,H,I>	Given an Fn8<A, B, C, D, E, F, G, H, I> and a Product8<A, B, C, D, E, F, G, H>, destructure the product and apply the slots as arguments to the function, returning the result.
final class	Iterate<A>	Lazily generate an infinite Iterable from the successive applications of the function first to the initial seed value, then to the result, and so on; i.e., the result of iterate(x -> x + 1, 0) would produce an infinite Iterable over the elements 0, 1, 2, 3, ...
final class	LazyRec<A,B>	Given a Fn2 that receives a recursive function and an input and yields a lazy result, and an input, produce a lazy result that, when forced, will recursively invoke the function until it terminates in a stack-safe way.
final class	LT<A extends Comparable<A>>	Given two Comparable values of type A, return true if the second value is strictly less than the first value; otherwise, return false.
final class	LTE<A extends Comparable<A>>	Given two Comparable values of type A, return true if the second value is less than or equal to the first value according to Comparable.compareTo(Object) otherwise, return false.
final class	MagnetizeBy<A>	Given a binary predicate and an Iterable<A>, return an Iterable<Iterable<A>> of the contiguous groups of elements that match the predicate pairwise.
final class	Map<A,B>	Lazily apply a function to each element in an Iterable, producing an Iterable of the mapped results.
final class	Partition<A,B,C>	Given an Iterable<A> as and a disjoint mapping function a -> CoProduct2<A, B>, return a Tuple2 over the lazily unwrapped left A and right B values in the first and second slots, respectively.
final class	Peek<A,FA extends Functor<A,?>>	Deprecated. in favor of producing an IO from the given Functor and explicitly running it
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
final class	PrependAll<A>	Lazily prepend each value with of the Iterable with the supplied separator value.
final class	ReduceLeft<A>	Given an Iterable<A> and a Fn2<A, A, A>, iteratively accumulate over the Iterable, returning Maybe<A>.
final class	ReduceRight<A>	Given an Iterable<A> and a Fn2<A, A, A>, iteratively accumulate over the Iterable, returning Maybe<A>.
final class	Replicate<A>	Produce an Iterable of a value n times.
final class	Sequence<A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>>	Given a Traversable of Applicatives and a pure Applicative constructor, traverse the elements from left to right, zipping the Applicatives together and collecting the results.
final class	Slide<A>	Given an Iterable<A>, "slide" a window of k elements across the Iterable by one element at a time, returning an Iterable<Iterable<A>>.
final class	Snoc<A>	Opposite of Cons: lazily append an element to the end of the given Iterable.
final class	SortBy<A,B extends Comparable<B>>	Given an Iterable and some mapping function from the Iterable element type to some Comparable type, produce a sorted List of the original elements based on sorting applied to the result of the mapping function.
final class	SortWith<A>	Given an Iterable and a Comparator over the Iterable element type, produce a sorted List of the original elements based on sorting applied by the Comparator.
final class	Span<A>	Given a predicate, return a Tuple2 where the first slot is the front contiguous elements of an Iterable matching the predicate and the second slot is all the remaining elements.
final class	Take<A>	Lazily limit the Iterable to n elements by returning an Iterable that stops iteration after the nth element, or the last element of the Iterable, whichever comes first.
final class	TakeWhile<A>	Lazily limit the Iterable to the first group of contiguous elements that satisfy the predicate by iterating up to, but not including, the first element for which the predicate evaluates to false.
final class	ToArray<A>	Write all the elements of an Iterable directly into an array of the specified type.
final class	ToCollection<A,C extends Collection<A>>	Given an Fn0 of some Collection C, create an instance of C and add all of the elements in the provided Iterable to the instance.
final class	ToMap<K,V,M extends Map<K,V>>	Given an Fn0 of some Map M, create an instance of M and put all of the entries in the provided Iterable into the instance.
final class	Tupler2<A,B>	Creates a Tuple2 from two values.
final class	Unfoldr<A,B>	Given an initial seed value and a function that takes the seed type and produces an Maybe<Tuple2<X, Seed>>, where the tuple's first slot represents the next Iterable element, and the second slot represents the next input to the unfolding function, unfold an Iterable of Xs.
final class	Until<A>	Given a predicate function for a value of some type A and an IO that yields a value of type A, produce an IO that repeatedly executes the original IO until the predicate returns true when applied to the yielded value.
final class	Zip<A,B>	Zip together two Iterables into a single Iterable of Tuple2<A, B>.

Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return Fn2

Modifier and Type	Method	Description
static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> Fn2<Fn1<? super B,? extends IO<?>>,FAB,FAB>	Peek2.peek2(Fn1<? super A,? extends IO<?>> effectA)	Deprecated.

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

Modifier and Type	Method	Description
C	Into.checkedApply(Fn2<? super A,? super B,? extends C> fn, Map.Entry<A,B> entry)
Lazy<B>	LazyRec.checkedApply(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn, A a)
Iterable<Iterable<A>>	MagnetizeBy.checkedApply(Fn2<? super A,? super A,? extends Boolean> predicate, Iterable<A> as)
Maybe<A>	ReduceLeft.checkedApply(Fn2<? super A,? super A,? extends A> fn, Iterable<A> as)
final Maybe<A>	ReduceRight.checkedApply(Fn2<? super A,? super A,? extends A> fn, Iterable<A> as)
static <A, B, C> Fn1<Map.Entry<A,B>,C>	Into.into(Fn2<? super A,? super B,? extends C> fn)
static <A, B, C> C	Into.into(Fn2<? super A,? super B,? extends C> fn, Map.Entry<A,B> entry)
static <A, B> Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>	LazyRec.lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn)
static <A, B> Lazy<B>	LazyRec.lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn, A a)
static <A> Fn1<Iterable<A>,Iterable<Iterable<A>>>	MagnetizeBy.magnetizeBy(Fn2<? super A,? super A,? extends Boolean> predicate)
static <A> Iterable<Iterable<A>>	MagnetizeBy.magnetizeBy(Fn2<? super A,? super A,? extends Boolean> predicate, Iterable<A> as)
static <A> Fn1<Iterable<A>,Maybe<A>>	ReduceLeft.reduceLeft(Fn2<? super A,? super A,? extends A> fn)
static <A> Maybe<A>	ReduceLeft.reduceLeft(Fn2<? super A,? super A,? extends A> fn, Iterable<A> as)
static <A> Fn1<Iterable<A>,Maybe<A>>	ReduceRight.reduceRight(Fn2<? super A,? super A,? extends A> fn)
static <A> Maybe<A>	ReduceRight.reduceRight(Fn2<? super A,? super A,? extends A> fn, Iterable<A> as)

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

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

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.

Methods in com.jnape.palatable.lambda.functions.builtin.fn3 that return Fn2

Modifier and Type	Method	Description
static <A, B> Fn2<Fn1<? super A,? extends IO<?>>,Fn1<? super A,? extends IO<B>>,IO<B>>	Bracket.bracket(IO<A> io)
static <A extends Comparable<A>> Fn2<A,A,A>	Clamp.clamp(A lower)
static <A> Fn2<A,A,ComparisonRelation>	Compare.compare(Comparator<A> comparator)
static <A, B> Fn2<B,Iterable<A>,B>	FoldLeft.foldLeft(Fn2<? super B,? super A,? extends B> fn)
static <A, B> Fn2<Lazy<B>,Iterable<A>,Lazy<B>>	FoldRight.foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn)
static <A, B, C, App extends Applicative<?, App>, AppC extends Applicative<C, App>> Fn2<Applicative<A,App>,Applicative<B,App>,AppC>	LiftA2.liftA2(Fn2<? super A,? super B,? extends C> fn)
static <A, B> Fn2<B,Iterable<A>,Iterable<B>>	ScanLeft.scanLeft(Fn2<? super B,? super A,? extends B> fn)
static <A> Fn2<Fn1<? super A,? extends A>,A,A>	Times.times(Integer n)
static <A, B, C> Fn2<Iterable<A>,Iterable<B>,Iterable<C>>	ZipWith.zipWith(Fn2<? super A,? super B,? extends C> zipper)

Methods in com.jnape.palatable.lambda.functions.builtin.fn3 with parameters of type Fn2

Modifier and Type	Method	Description
B	FoldLeft.checkedApply(Fn2<? super B,? super A,? extends B> fn, B acc, Iterable<A> as)
Lazy<B>	FoldRight.checkedApply(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc, Iterable<A> as)
AppC	LiftA2.checkedApply(Fn2<? super A,? super B,? extends C> fn, Applicative<A,App> appA, Applicative<B,App> appB)
Iterable<B>	ScanLeft.checkedApply(Fn2<? super B,? super A,? extends B> fn, B b, Iterable<A> as)
Iterable<C>	ZipWith.checkedApply(Fn2<? super A,? super B,? extends C> zipper, Iterable<A> as, Iterable<B> bs)
static <A, B> Fn2<B,Iterable<A>,B>	FoldLeft.foldLeft(Fn2<? super B,? super A,? extends B> fn)
static <A, B> Fn1<Iterable<A>,B>	FoldLeft.foldLeft(Fn2<? super B,? super A,? extends B> fn, B acc)
static <A, B> B	FoldLeft.foldLeft(Fn2<? super B,? super A,? extends B> fn, B acc, Iterable<A> as)
static <A, B> Fn2<Lazy<B>,Iterable<A>,Lazy<B>>	FoldRight.foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn)
static <A, B> Fn1<Iterable<A>,Lazy<B>>	FoldRight.foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc)
static <A, B> Lazy<B>	FoldRight.foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc, Iterable<A> as)
static <A, B, C, App extends Applicative<?, App>, AppC extends Applicative<C, App>> Fn2<Applicative<A,App>,Applicative<B,App>,AppC>	LiftA2.liftA2(Fn2<? super A,? super B,? extends C> fn)
static <A, B, C, App extends Applicative<?, App>, AppC extends Applicative<C, App>> Fn1<Applicative<B,App>,AppC>	LiftA2.liftA2(Fn2<? super A,? super B,? extends C> fn, Applicative<A,App> appA)
static <A, B, C, App extends Applicative<?, App>, AppC extends Applicative<C, App>> AppC	LiftA2.liftA2(Fn2<? super A,? super B,? extends C> fn, Applicative<A,App> appA, Applicative<B,App> appB)
static <A, B> Fn2<B,Iterable<A>,Iterable<B>>	ScanLeft.scanLeft(Fn2<? super B,? super A,? extends B> fn)
static <A, B> Fn1<Iterable<A>,Iterable<B>>	ScanLeft.scanLeft(Fn2<? super B,? super A,? extends B> fn, B b)
static <A, B> Iterable<B>	ScanLeft.scanLeft(Fn2<? super B,? super A,? extends B> fn, B b, Iterable<A> as)
static <A, B, C> Fn2<Iterable<A>,Iterable<B>,Iterable<C>>	ZipWith.zipWith(Fn2<? super A,? super B,? extends C> zipper)
static <A, B, C> Fn1<Iterable<B>,Iterable<C>>	ZipWith.zipWith(Fn2<? super A,? super B,? extends C> zipper, Iterable<A> as)
static <A, B, C> Iterable<C>	ZipWith.zipWith(Fn2<? super A,? super B,? extends C> zipper, Iterable<A> as, Iterable<B> bs)

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

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

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.

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

Modifier and Type	Method	Description
static <A, B> Fn2<Fn1<? super A,? extends B>,A,B>	IfThenElse.ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase)
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> Fn2<Duration,Iterable<A>,Iterable<A>>	RateLimit.rateLimit(Fn0<Instant> instantFn0, Long limit)

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

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

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 Fn2

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

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

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

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 Fn2

Modifier and Type	Method	Description
static <A, B, C, D, E, F, App extends Applicative<?, App>, AppF extends Applicative<F, App>> Fn2<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, Applicative<C,App> appC)

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

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

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 Fn2

Modifier and Type	Method	Description
static <A, B, C, D, E, F, G, App extends Applicative<?, App>, AppG extends Applicative<G, App>> Fn2<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, Applicative<D,App> appD)

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

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

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 Fn2

Modifier and Type	Method	Description
static <A, B, C, D, E, F, G, H, App extends Applicative<?, App>, AppH extends Applicative<H, App>> Fn2<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, Applicative<E,App> appE)

Uses of Fn2 in com.jnape.palatable.lambda.functions.recursion

Classes in com.jnape.palatable.lambda.functions.recursion that implement Fn2

Modifier and Type	Class	Description
final class	Trampoline<A,B>	Given an Fn1<A, CoProduct2<A, B, ?>> (analogous to "recurse" and "return" tail position instructions, respectively), produce a Fn1<A, B> that unrolls the original function by iteratively passing each result that matches the input (A) back to the original function, and then terminating on and returning the first output (B).

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

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

Modifier and Type	Interface	Description
interface	BiMonoidFactory<A,B,C>
interface	BiPredicate<A,B>	A specialized Fn2 that returns a Boolean when fully applied, or a Predicate when partially applied.
interface	BiSemigroupFactory<A,B,C>
interface	MonoidFactory<A,B>
interface	SemigroupFactory<A,B>

Methods in com.jnape.palatable.lambda.functions.specialized that return Fn2

Modifier and Type	Method	Description
default <Z> Fn2<Z,B,Boolean>	BiPredicate.contraMap(Fn1<? super Z,? extends A> fn)	Contravariantly map A <- B.

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

Modifier and Type	Method	Description
default <Y, Z> BiPredicate<Y,Z>	Predicate.compose(Fn2<? super Y,? super Z,? extends A> before)	Right-to-left composition between different arity functions.

Uses of Fn2 in com.jnape.palatable.lambda.internal.iteration

Fields in com.jnape.palatable.lambda.internal.iteration declared as Fn2

Modifier and Type	Field	Description
private final Fn2<? super B,? super A,? extends B>	ScanningIterator.scanner
private final Fn2<? super A,? super B,? extends C>	ZippingIterator.zipper

Constructors in com.jnape.palatable.lambda.internal.iteration with parameters of type Fn2

Modifier	Constructor	Description
	ScanningIterator(Fn2<? super B,? super A,? extends B> scanner, B b, Iterator<A> asIterator)
	ZippingIterator(Fn2<? super A,? super B,? extends C> zipper, Iterator<A> asIterator, Iterator<B> bsIterator)

Uses of Fn2 in com.jnape.palatable.lambda.monad.transformer.builtin

Methods in com.jnape.palatable.lambda.monad.transformer.builtin with parameters of type Fn2

Modifier and Type	Method	Description
<B, MB extends MonadRec<B, M>> MB	IterateT.fold(Fn2<? super B,? super A,? extends MonadRec<B,M>> fn, MonadRec<B,M> acc)	Monolithically fold the spine of this IterateT by trampolining the underlying effects (for iterative folding, use trampolineM directly).
<B, MB extends MonadRec<B, M>> MB	IterateT.foldCut(Fn2<? super B,? super A,? extends MonadRec<RecursiveResult<B,B>,M>> fn, MonadRec<B,M> acc)	Monolithically fold the spine of this IterateT (with the possibility of early termination) by trampolining the underlying effects (for iterative folding, use trampolineM directly).

Uses of Fn2 in com.jnape.palatable.lambda.monoid

Subinterfaces of Fn2 in com.jnape.palatable.lambda.monoid

Modifier and Type	Interface	Description
interface	Monoid<A>	A Monoid is the pairing of a Semigroup with an identity element.

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

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

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	And	A Monoid instance formed by Boolean.
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	Concat<A>	The Monoid instance formed under concatenation for an arbitrary Iterable.
final class	Endo<A>	A Monoid formed by Fn1 under composition.
final class	EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>	The monoid formed under monadic endomorphism.
final class	First<A>	A Monoid instance formed by Maybe<A>.
final class	Join	A Monoid instance formed by String that concats two strings together.
final class	Last<A>	A Monoid instance formed by Maybe<A>.
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(com.jnape.palatable.lambda.functions.Fn2<? super L, ? super L, ? extends L>, com.jnape.palatable.lambda.functions.Fn2<? super R, ? super R, ? extends R>, com.jnape.palatable.lambda.adt.Either<L, R>...), a semigroup over L, and a monoid over R.
final class	MergeHMaps	A Monoid instance formed by merging HMaps using the chosen TypeSafeKey -> Semigroup mappings, defaulting to Last in case no Semigroup has been chosen for a given TypeSafeKey.
final class	MergeMaps<K,V>	A Monoid instance formed by Map.merge(Object, Object, BiFunction) and a semigroup over V.
final class	Or	A Monoid instance formed by Boolean.
final class	Present<A>	A Monoid instance formed by Maybe<A> and a semigroup over A.
final class	PutAll	A Monoid instance formed by HMap that simply combines all the mappings.
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.
final class	Trivial	The trivial Unit Monoid formed under constantly.
final class	Union<A>	Given two Iterables xs and ys, return the concatenation of the distinct elements of both xs and ys.
final class	Xor	Logical exclusive-or.

Fields in com.jnape.palatable.lambda.monoid.builtin with type parameters of type Fn2

Modifier and Type	Field	Description
private final Map<TypeSafeKey<?,?>,Fn2<HMap,HMap,HMap>>	MergeHMaps.bindings
private final MergeHMaps.Φ<Fn2<HMap,HMap,HMap>>	MergeHMaps.defaultBinding

Methods in com.jnape.palatable.lambda.monoid.builtin that return Fn2

Modifier and Type	Method	Description
Fn2<Fn1<A,A>,A,A>	Endo.apply(Fn1<A,A> f)
static <A> Fn2<Fn1<A,A>,A,A>	Endo.endo(Fn1<A,A> f)
private static <A> Fn2<HMap,HMap,HMap>	MergeHMaps.merge(TypeSafeKey<?,A> key, Semigroup<Maybe<A>> semigroup)

Constructor parameters in com.jnape.palatable.lambda.monoid.builtin with type arguments of type Fn2

Modifier	Constructor	Description
private	MergeHMaps(Map<TypeSafeKey<?,?>,Fn2<HMap,HMap,HMap>> bindings, MergeHMaps.Φ<Fn2<HMap,HMap,HMap>> defaultBinding)
private	MergeHMaps(Map<TypeSafeKey<?,?>,Fn2<HMap,HMap,HMap>> bindings, MergeHMaps.Φ<Fn2<HMap,HMap,HMap>> defaultBinding)

Uses of Fn2 in com.jnape.palatable.lambda.optics

Methods in com.jnape.palatable.lambda.optics with parameters of type Fn2

Modifier and Type	Method	Description
static <S, T, A, B> Lens<S,T,A,B>	Lens.lens(Fn1<? super S,? extends A> getter, Fn2<? super S,? super B,? extends T> setter)	Static factory method for creating a lens from a getter function and a setter function.
static <S, A> Lens.Simple<S,A>	Lens.simpleLens(Fn1<? super S,? extends A> getter, Fn2<? super S,? super A,? extends S> setter)	Static factory method for creating a simple lens from a getter function and a setter function.

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

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

Modifier and Type	Class	Description
final class	Matching<S,T,A,B>
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).
final class	View<S,T,A,B>	Given an Optic and a "larger" value S, retrieve a "smaller" value A by lifting the Optic into the Const functor.

Methods in com.jnape.palatable.lambda.optics.functions that return Fn2

Modifier and Type	Method	Description
static <S, T, A, B> Fn2<Fn1<? super A,? extends B>,S,T>	Over.over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic)
static <S, T, A, B> Fn2<B,S,T>	Set.set(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic)
static <S, T, A, B> Fn2<Fn1<? super T,? extends S>,B,A>	Under.under(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic)

Uses of Fn2 in com.jnape.palatable.lambda.semigroup

Subinterfaces of Fn2 in com.jnape.palatable.lambda.semigroup

Modifier and Type	Interface	Description
interface	Semigroup<A>	A Semigroup is a closed, associative category.

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

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

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	Intersection<A>	Given two Iterables xs and ys, return the distinct elements of xs that are also in ys in order of their unique occurrence in xs.
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	Max<A extends Comparable<A>>	A Semigroup over A that chooses between two values x and y via the following rules: If x is strictly less than y, return y Otherwise, return x
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(com.jnape.palatable.lambda.functions.Fn2<? super L, ? super L, ? extends L>, com.jnape.palatable.lambda.functions.Fn2<? super R, ? super R, ? extends R>, com.jnape.palatable.lambda.adt.Either<L, R>...) and semigroups over L and R.
final class	Min<A extends Comparable<A>>	A Semigroup over A that chooses between two values x and y via the following rules: If x is strictly greater than y, return y Otherwise, return x
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.