Modifier and Type | Method and 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.
|
Modifier and Type | Interface and 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 six arguments.
|
interface |
Fn8<A,B,C,D,E,F,G,H,I>
A function taking six arguments.
|
Modifier and Type | Method and 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 <A,B,C,D> Fn3<A,B,C,D> |
Fn3.fn3(Fn2<A,B,Fn1<C,D>> curriedFn2)
|
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()
|
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.
|
Modifier and Type | Method and 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.fn4(Fn3<A,B,C,Fn1<D,E>> curriedFn3)
|
static <A,B,C,D,E,F> |
Fn5.fn5(Fn3<A,B,C,Fn2<D,E,F>> curriedFn3)
|
static <A,B,C,D,E,F,G> |
Fn6.fn6(Fn3<A,B,C,Fn3<D,E,F,G>> curriedFn3)
|
static <A,B,C,D,E,F,G,H> |
Fn7.fn7(Fn3<A,B,C,Fn4<D,E,F,G,H>> curriedFn3)
|
static <A,B,C,D,E,F,G,H,I> |
Fn8.fn8(Fn3<A,B,C,Fn5<D,E,F,G,H,I>> curriedFn3)
|
Modifier and Type | Method and Description |
---|---|
static <A,B,C,D,E> |
Fn4.fn4(Fn1<A,Fn3<B,C,D,E>> curriedFn1)
|
static <A,B,C,D,E,F> |
Fn5.fn5(Fn2<A,B,Fn3<C,D,E,F>> curriedFn2)
|
static <A,B,C,D,E,F,G> |
Fn6.fn6(Fn3<A,B,C,Fn3<D,E,F,G>> curriedFn3)
|
static <A,B,C,D,E,F,G,H> |
Fn7.fn7(Fn4<A,B,C,D,Fn3<E,F,G,H>> curriedFn4)
|
static <A,B,C,D,E,F,G,H,I> |
Fn8.fn8(Fn5<A,B,C,D,E,Fn3<F,G,H,I>> curriedFn5)
|
Modifier and Type | Class and Description |
---|---|
class |
Both<A,B,C>
|
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 |
Modifier and Type | Method and 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) |
Modifier and Type | Class and Description |
---|---|
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.
|
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
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. |
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
|
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. |
class |
FoldLeft<A,B>
Given an
Iterable of A s, a starting value B , and a
, iteratively accumulate over the Iterable , ultimately returning
a final B value. |
class |
FoldRight<A,B>
|
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. |
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. |
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. |
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. |
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. |
class |
ScanLeft<A,B>
Given an
Iterable of A s, a starting value B , and a
, iteratively accumulate over the Iterable , collecting each
function application result, finally returning an Iterable of all the results. |
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. |
class |
ZipWith<A,B,C>
Zip together two
Iterable s by applying a zipping function to the successive elements of each
Iterable until one of them runs out of elements. |
Modifier and Type | Class and Description |
---|---|
class |
IfThenElse<A,B> |
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. |
class |
RateLimit<A>
|
Modifier and Type | Method and 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>> |
LiftA3.liftA3(Fn3<A,B,C,D> fn) |
static <A> Fn3<Long,Duration,Iterable<A>,Iterable<A>> |
RateLimit.rateLimit(Fn0<Instant> instantFn0) |
Modifier and Type | Method and 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>> |
LiftA3.liftA3(Fn3<A,B,C,D> fn) |
static <A,B,C,D,App extends Applicative<?,App>,AppD extends Applicative<D,App>> |
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>> |
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>> |
LiftA3.liftA3(Fn3<A,B,C,D> fn,
Applicative<A,App> appA,
Applicative<B,App> appB,
Applicative<C,App> appC) |
Modifier and Type | Class and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
static <A,B,C,D,E,App extends Applicative<?,App>,AppE extends Applicative<E,App>> |
LiftA4.liftA4(Fn4<A,B,C,D,E> fn,
Applicative<A,App> appA) |
Modifier and Type | Class and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
static <A,B,C,D,E,F,App extends Applicative<?,App>,AppF extends Applicative<F,App>> |
LiftA5.liftA5(Fn5<A,B,C,D,E,F> fn,
Applicative<A,App> appA,
Applicative<B,App> appB) |
Modifier and Type | Class and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
static <A,B,C,D,E,F,G,App extends Applicative<?,App>,AppG extends Applicative<G,App>> |
LiftA6.liftA6(Fn6<A,B,C,D,E,F,G> fn,
Applicative<A,App> appA,
Applicative<B,App> appB,
Applicative<C,App> appC) |
Modifier and Type | Class and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
static <A,B,C,D,E,F,G,H,App extends Applicative<?,App>,AppH extends Applicative<H,App>> |
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) |
Modifier and Type | Interface and Description |
---|---|
interface |
BiMonoidFactory<A,B,C> |
interface |
BiSemigroupFactory<A,B,C> |
interface |
MonoidFactory<A,B> |
interface |
SemigroupFactory<A,B> |
Modifier and Type | Class and Description |
---|---|
class |
AddAll<A,C extends Collection<A>>
The
Monoid instance formed under mutative concatenation for an arbitrary Collection . |
class |
Collapse<_1,_2>
|
class |
Compose<A>
|
class |
EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>
The monoid formed under monadic endomorphism.
|
class |
LeftAll<L,R>
|
class |
LeftAny<L,R>
|
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 . |
class |
MergeMaps<K,V>
|
class |
Present<A>
|
class |
RightAll<L,R>
|
class |
RightAny<L,R>
|
class |
RunAll<A>
|
Modifier and Type | Class and Description |
---|---|
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. |
class |
Set<S,T,A,B>
|
class |
Under<S,T,A,B>
|
Modifier and Type | Class and Description |
---|---|
class |
Absent<A>
|
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
|
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
|