| Modifier and Type | Method and Description |
|---|---|
<C,D> These<C,D> |
These.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually map covariantly over both the left and right parameters.
|
<C,D> These<C,D> |
These.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually map covariantly over both the left and right parameters.
|
<L2,R2> Either<L2,R2> |
Either.biMap(Fn1<? super L,? extends L2> leftFn,
Fn1<? super R,? extends R2> rightFn)
Dually map covariantly over both the left and right parameters.
|
<L2,R2> Either<L2,R2> |
Either.biMap(Fn1<? super L,? extends L2> leftFn,
Fn1<? super R,? extends R2> rightFn)
Dually map covariantly over both the left and right parameters.
|
<Z> These<Z,B> |
These.biMapL(Fn1<? super A,? extends Z> fn)
Covariantly map over the left parameter.
|
<L2> Either<L2,R> |
Either.biMapL(Fn1<? super L,? extends L2> fn)
Covariantly map over the left parameter.
|
<C> These<A,C> |
These.biMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the right parameter.
|
<R2> Either<L,R2> |
Either.biMapR(Fn1<? super R,? extends R2> fn)
Covariantly map over the right parameter.
|
Either<L,R> |
Either.catchError(Fn1<? super L,? extends Monad<R,Either<L,?>>> recoveryFn)
|
Try<A> |
Try.catchError(Fn1<? super Throwable,? extends Monad<A,Try<?>>> recoveryFn)
|
Maybe<A> |
Maybe.catchError(Fn1<? super Unit,? extends Monad<A,Maybe<?>>> recoveryFn)
|
<S extends Throwable> |
Try.catching(Class<S> throwableType,
Fn1<? super S,? extends A> recoveryFn)
Catch any instance of
throwableType and map it to a success value. |
Try<A> |
Try.catching(Fn1<? super Throwable,? extends Boolean> predicate,
Fn1<? super Throwable,? extends A> recoveryFn)
Catch any thrown
T satisfying predicate and map it to a success value. |
Try<A> |
Try.catching(Fn1<? super Throwable,? extends Boolean> predicate,
Fn1<? super Throwable,? extends A> recoveryFn)
Catch any thrown
T satisfying predicate and map it to a success value. |
Maybe<A> |
Maybe.filter(Fn1<? super A,? extends Boolean> predicate)
If this value is present and satisfies
predicate, return just the value; otherwise,
return nothing. |
Either<L,R> |
Either.filter(Fn1<? super R,? extends Boolean> pred,
Fn0<L> leftFn0)
If this is a right value, apply
pred to it. |
Either<L,R> |
Either.filter(Fn1<? super R,? extends Boolean> pred,
Fn1<? super R,? extends L> leftFn)
If this is a right value, apply
pred to it. |
Either<L,R> |
Either.filter(Fn1<? super R,? extends Boolean> pred,
Fn1<? super R,? extends L> leftFn)
If this is a right value, apply
pred to it. |
<B> Maybe<B> |
Maybe.flatMap(Fn1<? super A,? extends Monad<B,Maybe<?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> Try<B> |
Try.flatMap(Fn1<? super A,? extends Monad<B,Try<?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<C> These<A,C> |
These.flatMap(Fn1<? super B,? extends Monad<C,These<A,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<R2> Either<L,R2> |
Either.flatMap(Fn1<? super R,? extends Monad<R2,Either<L,?>>> rightFn)
If a right value, unwrap it and apply it to
rightFn, returning the resulting
Either<L ,R>. |
<B> Maybe<B> |
Maybe.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> Try<B> |
Try.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<C> These<A,C> |
These.fmap(Fn1<? super B,? extends C> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<R2> Either<L,R2> |
Either.fmap(Fn1<? super R,? extends R2> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
Throwable |
Try.forfeit(Fn1<? super A,? extends Throwable> fn)
If this is a failure, return the wrapped value.
|
L |
Either.forfeit(Fn1<? super R,? extends L> forfeitFn)
Inverse of recover.
|
abstract <V> V |
Either.match(Fn1<? super L,? extends V> leftFn,
Fn1<? super R,? extends V> rightFn)
Given two mapping functions (one from an
L to a V, one from an R to a
V), unwrap the value stored in this Either, apply the appropriate mapping function,
and return the result. |
abstract <V> V |
Either.match(Fn1<? super L,? extends V> leftFn,
Fn1<? super R,? extends V> rightFn)
Given two mapping functions (one from an
L to a V, one from an R to a
V), unwrap the value stored in this Either, apply the appropriate mapping function,
and return the result. |
<T extends Throwable> |
Either.orThrow(Fn1<? super L,? extends T> throwableFn)
Return the wrapped value if this is a right; otherwise, map the wrapped left value to a
T and throw
it. |
abstract <T extends Throwable> |
Try.orThrow(Fn1<? super Throwable,? extends T> fn)
If this is a success value, return it.
|
Maybe<A> |
Maybe.peek(Fn1<? super A,? extends IO<?>> effect)
|
Either<L,R> |
Either.peek(Fn1<? super L,? extends IO<?>> leftEffect,
Fn1<? super R,? extends IO<?>> rightEffect)
|
Either<L,R> |
Either.peek(Fn1<? super L,? extends IO<?>> leftEffect,
Fn1<? super R,? extends IO<?>> rightEffect)
|
Either<L,R> |
Either.peek(Fn1<? super R,? extends IO<?>> effect)
|
R |
Either.recover(Fn1<? super L,? extends R> recoveryFn)
"Recover" from a left value by applying a recoveryFn to the wrapped value and returning it in the case of a left
value; otherwise, return the wrapped right value.
|
A |
Try.recover(Fn1<? super Throwable,? extends A> fn)
If this is a success, return the wrapped value.
|
<L> Either<L,A> |
Try.toEither(Fn1<? super Throwable,? extends L> fn)
If this is a success, wrap the value in a
Either.right(R) and return it. |
<B> Maybe<B> |
Maybe.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Maybe<?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> Try<B> |
Try.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Try<?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<C> These<A,C> |
These.trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,These<A,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> Either<L,B> |
Either.trampolineM(Fn1<? super R,? extends MonadRec<RecursiveResult<R,B>,Either<L,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,Maybe<?>>,AppTrav extends Applicative<TravB,App>> |
Maybe.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure) |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,Maybe<?>>,AppTrav extends Applicative<TravB,App>> |
Maybe.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure) |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,Try<?>>,AppTrav extends Applicative<TravB,App>> |
Try.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,Try<?>>,AppTrav extends Applicative<TravB,App>> |
Try.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<C,App extends Applicative<?,App>,TravC extends Traversable<C,These<A,?>>,AppTrav extends Applicative<TravC,App>> |
These.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravC,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<C,App extends Applicative<?,App>,TravC extends Traversable<C,These<A,?>>,AppTrav extends Applicative<TravC,App>> |
These.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravC,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<R2,App extends Applicative<?,App>,TravB extends Traversable<R2,Either<L,?>>,AppTrav extends Applicative<TravB,App>> |
Either.traverse(Fn1<? super R,? extends Applicative<R2,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<R2,App extends Applicative<?,App>,TravB extends Traversable<R2,Either<L,?>>,AppTrav extends Applicative<TravB,App>> |
Either.traverse(Fn1<? super R,? extends Applicative<R2,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
static <L,R> Either<L,R> |
Either.trying(Fn0<? extends R> fn0,
Fn1<? super Throwable,? extends L> leftFn)
Attempt to execute the
Fn0, returning its result in a right value. |
static <L> Either<L,Unit> |
Either.trying(SideEffect sideEffect,
Fn1<? super Throwable,? extends L> leftFn)
Attempt to execute the
SideEffect, returning Unit in a right value. |
static <A extends AutoCloseable,B extends AutoCloseable,C extends AutoCloseable,D> |
Try.withResources(Fn0<? extends A> fn0,
Fn1<? super A,? extends B> bFn,
Fn1<? super B,? extends C> cFn,
Fn1<? super C,? extends Try<? extends D>> fn)
Convenience overload of
withResources that
cascades
two dependent resource creations via nested calls. |
static <A extends AutoCloseable,B extends AutoCloseable,C extends AutoCloseable,D> |
Try.withResources(Fn0<? extends A> fn0,
Fn1<? super A,? extends B> bFn,
Fn1<? super B,? extends C> cFn,
Fn1<? super C,? extends Try<? extends D>> fn)
Convenience overload of
withResources that
cascades
two dependent resource creations via nested calls. |
static <A extends AutoCloseable,B extends AutoCloseable,C extends AutoCloseable,D> |
Try.withResources(Fn0<? extends A> fn0,
Fn1<? super A,? extends B> bFn,
Fn1<? super B,? extends C> cFn,
Fn1<? super C,? extends Try<? extends D>> fn)
Convenience overload of
withResources that
cascades
two dependent resource creations via nested calls. |
static <A extends AutoCloseable,B extends AutoCloseable,C> |
Try.withResources(Fn0<? extends A> fn0,
Fn1<? super A,? extends B> bFn,
Fn1<? super B,? extends Try<? extends C>> fn)
Convenience overload of
withResources that cascades dependent resource
creation via nested calls. |
static <A extends AutoCloseable,B extends AutoCloseable,C> |
Try.withResources(Fn0<? extends A> fn0,
Fn1<? super A,? extends B> bFn,
Fn1<? super B,? extends Try<? extends C>> fn)
Convenience overload of
withResources that cascades dependent resource
creation via nested calls. |
static <A extends AutoCloseable,B> |
Try.withResources(Fn0<? extends A> fn0,
Fn1<? super A,? extends Try<? extends B>> fn)
Given a
aSupplier and an Fn1
fn, apply fn to the result of aSupplier, ensuring that the result has its
close method invoked, regardless of the outcome. |
| Modifier and Type | Method and Description |
|---|---|
<B> Lazy<Maybe<B>> |
Maybe.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Maybe<?>>> lazyAppFn)
Terminate early if this is a
Nothing; otherwise, continue the zip. |
<B> Lazy<Try<B>> |
Try.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Try<?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<C> Lazy<These<A,C>> |
These.lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,These<A,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<R2> Lazy<Either<L,R2>> |
Either.lazyZip(Lazy<? extends Applicative<Fn1<? super R,? extends R2>,Either<L,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Maybe<B> |
Maybe.zip(Applicative<Fn1<? super A,? extends B>,Maybe<?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> Try<B> |
Try.zip(Applicative<Fn1<? super A,? extends B>,Try<?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<C> These<A,C> |
These.zip(Applicative<Fn1<? super B,? extends C>,These<A,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<R2> Either<L,R2> |
Either.zip(Applicative<Fn1<? super R,? extends R2>,Either<L,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Method and Description |
|---|---|
<C,D> Choice2<C,D> |
Choice2.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually map covariantly over both the left and right parameters.
|
<C,D> Choice2<C,D> |
Choice2.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually map covariantly over both the left and right parameters.
|
<D,E> Choice3<A,D,E> |
Choice3.biMap(Fn1<? super B,? extends D> lFn,
Fn1<? super C,? extends E> rFn)
Dually map covariantly over both the left and right parameters.
|
<D,E> Choice3<A,D,E> |
Choice3.biMap(Fn1<? super B,? extends D> lFn,
Fn1<? super C,? extends E> rFn)
Dually map covariantly over both the left and right parameters.
|
<E,F> Choice4<A,B,E,F> |
Choice4.biMap(Fn1<? super C,? extends E> lFn,
Fn1<? super D,? extends F> rFn) |
<E,F> Choice4<A,B,E,F> |
Choice4.biMap(Fn1<? super C,? extends E> lFn,
Fn1<? super D,? extends F> rFn) |
<F,G> Choice5<A,B,C,F,G> |
Choice5.biMap(Fn1<? super D,? extends F> lFn,
Fn1<? super E,? extends G> rFn)
Dually map covariantly over both the left and right parameters.
|
<F,G> Choice5<A,B,C,F,G> |
Choice5.biMap(Fn1<? super D,? extends F> lFn,
Fn1<? super E,? extends G> rFn)
Dually map covariantly over both the left and right parameters.
|
<G,H> Choice6<A,B,C,D,G,H> |
Choice6.biMap(Fn1<? super E,? extends G> lFn,
Fn1<? super F,? extends H> rFn)
Dually map covariantly over both the left and right parameters.
|
<G,H> Choice6<A,B,C,D,G,H> |
Choice6.biMap(Fn1<? super E,? extends G> lFn,
Fn1<? super F,? extends H> rFn)
Dually map covariantly over both the left and right parameters.
|
<H,I> Choice7<A,B,C,D,E,H,I> |
Choice7.biMap(Fn1<? super F,? extends H> lFn,
Fn1<? super G,? extends I> rFn)
Dually map covariantly over both the left and right parameters.
|
<H,I> Choice7<A,B,C,D,E,H,I> |
Choice7.biMap(Fn1<? super F,? extends H> lFn,
Fn1<? super G,? extends I> rFn)
Dually map covariantly over both the left and right parameters.
|
<I,J> Choice8<A,B,C,D,E,F,I,J> |
Choice8.biMap(Fn1<? super G,? extends I> lFn,
Fn1<? super H,? extends J> rFn)
Dually map covariantly over both the left and right parameters.
|
<I,J> Choice8<A,B,C,D,E,F,I,J> |
Choice8.biMap(Fn1<? super G,? extends I> lFn,
Fn1<? super H,? extends J> rFn)
Dually map covariantly over both the left and right parameters.
|
<C> Choice2<C,B> |
Choice2.biMapL(Fn1<? super A,? extends C> fn)
Covariantly map over the left parameter.
|
<D> Choice3<A,D,C> |
Choice3.biMapL(Fn1<? super B,? extends D> fn)
Covariantly map over the left parameter.
|
<E> Choice4<A,B,E,D> |
Choice4.biMapL(Fn1<? super C,? extends E> fn)
Covariantly map over the left parameter.
|
<F> Choice5<A,B,C,F,E> |
Choice5.biMapL(Fn1<? super D,? extends F> fn)
Covariantly map over the left parameter.
|
<G> Choice6<A,B,C,D,G,F> |
Choice6.biMapL(Fn1<? super E,? extends G> fn)
Covariantly map over the left parameter.
|
<H> Choice7<A,B,C,D,E,H,G> |
Choice7.biMapL(Fn1<? super F,? extends H> fn)
Covariantly map over the left parameter.
|
<I> Choice8<A,B,C,D,E,F,I,H> |
Choice8.biMapL(Fn1<? super G,? extends I> fn)
Covariantly map over the left parameter.
|
<C> Choice2<A,C> |
Choice2.biMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the right parameter.
|
<D> Choice3<A,B,D> |
Choice3.biMapR(Fn1<? super C,? extends D> fn)
Covariantly map over the right parameter.
|
<E> Choice4<A,B,C,E> |
Choice4.biMapR(Fn1<? super D,? extends E> fn)
Covariantly map over the right parameter.
|
<F> Choice5<A,B,C,D,F> |
Choice5.biMapR(Fn1<? super E,? extends F> fn)
Covariantly map over the right parameter.
|
<G> Choice6<A,B,C,D,E,G> |
Choice6.biMapR(Fn1<? super F,? extends G> fn)
Covariantly map over the right parameter.
|
<H> Choice7<A,B,C,D,E,F,H> |
Choice7.biMapR(Fn1<? super G,? extends H> fn)
Covariantly map over the right parameter.
|
<I> Choice8<A,B,C,D,E,F,G,I> |
Choice8.biMapR(Fn1<? super H,? extends I> fn)
Covariantly map over the right parameter.
|
Choice2<A,B> |
Choice3.converge(Fn1<? super C,? extends CoProduct2<A,B,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
Choice3<A,B,C> |
Choice4.converge(Fn1<? super D,? extends CoProduct3<A,B,C,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
Choice4<A,B,C,D> |
Choice5.converge(Fn1<? super E,? extends CoProduct4<A,B,C,D,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
Choice5<A,B,C,D,E> |
Choice6.converge(Fn1<? super F,? extends CoProduct5<A,B,C,D,E,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
Choice6<A,B,C,D,E,F> |
Choice7.converge(Fn1<? super G,? extends CoProduct6<A,B,C,D,E,F,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
Choice7<A,B,C,D,E,F,G> |
Choice8.converge(Fn1<? super H,? extends CoProduct7<A,B,C,D,E,F,G,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
<C> Choice2<A,C> |
Choice2.flatMap(Fn1<? super B,? extends Monad<C,Choice2<A,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<D> Choice3<A,B,D> |
Choice3.flatMap(Fn1<? super C,? extends Monad<D,Choice3<A,B,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<E> Choice4<A,B,C,E> |
Choice4.flatMap(Fn1<? super D,? extends Monad<E,Choice4<A,B,C,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<F> Choice5<A,B,C,D,F> |
Choice5.flatMap(Fn1<? super E,? extends Monad<F,Choice5<A,B,C,D,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<G> Choice6<A,B,C,D,E,G> |
Choice6.flatMap(Fn1<? super F,? extends Monad<G,Choice6<A,B,C,D,E,?>>> fn)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<H> Choice7<A,B,C,D,E,F,H> |
Choice7.flatMap(Fn1<? super G,? extends Monad<H,Choice7<A,B,C,D,E,F,?>>> fn)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<I> Choice8<A,B,C,D,E,F,G,I> |
Choice8.flatMap(Fn1<? super H,? extends Monad<I,Choice8<A,B,C,D,E,F,G,?>>> fn)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<C> Choice2<A,C> |
Choice2.fmap(Fn1<? super B,? extends C> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<D> Choice3<A,B,D> |
Choice3.fmap(Fn1<? super C,? extends D> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<E> Choice4<A,B,C,E> |
Choice4.fmap(Fn1<? super D,? extends E> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<F> Choice5<A,B,C,D,F> |
Choice5.fmap(Fn1<? super E,? extends F> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<G> Choice6<A,B,C,D,E,G> |
Choice6.fmap(Fn1<? super F,? extends G> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<H> Choice7<A,B,C,D,E,F,H> |
Choice7.fmap(Fn1<? super G,? extends H> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<I> Choice8<A,B,C,D,E,F,G,I> |
Choice8.fmap(Fn1<? super H,? extends I> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<C> Choice2<A,C> |
Choice2.trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Choice2<A,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<D> Choice3<A,B,D> |
Choice3.trampolineM(Fn1<? super C,? extends MonadRec<RecursiveResult<C,D>,Choice3<A,B,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<E> Choice4<A,B,C,E> |
Choice4.trampolineM(Fn1<? super D,? extends MonadRec<RecursiveResult<D,E>,Choice4<A,B,C,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<F> Choice5<A,B,C,D,F> |
Choice5.trampolineM(Fn1<? super E,? extends MonadRec<RecursiveResult<E,F>,Choice5<A,B,C,D,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<G> Choice6<A,B,C,D,E,G> |
Choice6.trampolineM(Fn1<? super F,? extends MonadRec<RecursiveResult<F,G>,Choice6<A,B,C,D,E,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<H> Choice7<A,B,C,D,E,F,H> |
Choice7.trampolineM(Fn1<? super G,? extends MonadRec<RecursiveResult<G,H>,Choice7<A,B,C,D,E,F,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<I> Choice8<A,B,C,D,E,F,G,I> |
Choice8.trampolineM(Fn1<? super H,? extends MonadRec<RecursiveResult<H,I>,Choice8<A,B,C,D,E,F,G,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<C,App extends Applicative<?,App>,TravB extends Traversable<C,Choice2<A,?>>,AppTrav extends Applicative<TravB,App>> |
Choice2.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<C,App extends Applicative<?,App>,TravB extends Traversable<C,Choice2<A,?>>,AppTrav extends Applicative<TravB,App>> |
Choice2.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<D,App extends Applicative<?,App>,TravB extends Traversable<D,Choice3<A,B,?>>,AppTrav extends Applicative<TravB,App>> |
Choice3.traverse(Fn1<? super C,? extends Applicative<D,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<D,App extends Applicative<?,App>,TravB extends Traversable<D,Choice3<A,B,?>>,AppTrav extends Applicative<TravB,App>> |
Choice3.traverse(Fn1<? super C,? extends Applicative<D,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<E,App extends Applicative<?,App>,TravB extends Traversable<E,Choice4<A,B,C,?>>,AppTrav extends Applicative<TravB,App>> |
Choice4.traverse(Fn1<? super D,? extends Applicative<E,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<E,App extends Applicative<?,App>,TravB extends Traversable<E,Choice4<A,B,C,?>>,AppTrav extends Applicative<TravB,App>> |
Choice4.traverse(Fn1<? super D,? extends Applicative<E,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<F,App extends Applicative<?,App>,TravB extends Traversable<F,Choice5<A,B,C,D,?>>,AppTrav extends Applicative<TravB,App>> |
Choice5.traverse(Fn1<? super E,? extends Applicative<F,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<F,App extends Applicative<?,App>,TravB extends Traversable<F,Choice5<A,B,C,D,?>>,AppTrav extends Applicative<TravB,App>> |
Choice5.traverse(Fn1<? super E,? extends Applicative<F,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<G,App extends Applicative<?,App>,TravB extends Traversable<G,Choice6<A,B,C,D,E,?>>,AppTrav extends Applicative<TravB,App>> |
Choice6.traverse(Fn1<? super F,? extends Applicative<G,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<G,App extends Applicative<?,App>,TravB extends Traversable<G,Choice6<A,B,C,D,E,?>>,AppTrav extends Applicative<TravB,App>> |
Choice6.traverse(Fn1<? super F,? extends Applicative<G,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<H,App extends Applicative<?,App>,TravB extends Traversable<H,Choice7<A,B,C,D,E,F,?>>,AppTrav extends Applicative<TravB,App>> |
Choice7.traverse(Fn1<? super G,? extends Applicative<H,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<H,App extends Applicative<?,App>,TravB extends Traversable<H,Choice7<A,B,C,D,E,F,?>>,AppTrav extends Applicative<TravB,App>> |
Choice7.traverse(Fn1<? super G,? extends Applicative<H,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<I,App extends Applicative<?,App>,TravB extends Traversable<I,Choice8<A,B,C,D,E,F,G,?>>,AppTrav extends Applicative<TravB,App>> |
Choice8.traverse(Fn1<? super H,? extends Applicative<I,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<I,App extends Applicative<?,App>,TravB extends Traversable<I,Choice8<A,B,C,D,E,F,G,?>>,AppTrav extends Applicative<TravB,App>> |
Choice8.traverse(Fn1<? super H,? extends Applicative<I,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
| Modifier and Type | Method and Description |
|---|---|
<C> Lazy<Choice2<A,C>> |
Choice2.lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Choice2<A,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<D> Lazy<Choice3<A,B,D>> |
Choice3.lazyZip(Lazy<? extends Applicative<Fn1<? super C,? extends D>,Choice3<A,B,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<E> Lazy<Choice4<A,B,C,E>> |
Choice4.lazyZip(Lazy<? extends Applicative<Fn1<? super D,? extends E>,Choice4<A,B,C,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<F> Lazy<Choice5<A,B,C,D,F>> |
Choice5.lazyZip(Lazy<? extends Applicative<Fn1<? super E,? extends F>,Choice5<A,B,C,D,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<G> Lazy<Choice6<A,B,C,D,E,G>> |
Choice6.lazyZip(Lazy<? extends Applicative<Fn1<? super F,? extends G>,Choice6<A,B,C,D,E,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<H> Lazy<Choice7<A,B,C,D,E,F,H>> |
Choice7.lazyZip(Lazy<? extends Applicative<Fn1<? super G,? extends H>,Choice7<A,B,C,D,E,F,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<I> Lazy<Choice8<A,B,C,D,E,F,G,I>> |
Choice8.lazyZip(Lazy<? extends Applicative<Fn1<? super H,? extends I>,Choice8<A,B,C,D,E,F,G,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<C> Choice2<A,C> |
Choice2.zip(Applicative<Fn1<? super B,? extends C>,Choice2<A,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<D> Choice3<A,B,D> |
Choice3.zip(Applicative<Fn1<? super C,? extends D>,Choice3<A,B,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<E> Choice4<A,B,C,E> |
Choice4.zip(Applicative<Fn1<? super D,? extends E>,Choice4<A,B,C,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<F> Choice5<A,B,C,D,F> |
Choice5.zip(Applicative<Fn1<? super E,? extends F>,Choice5<A,B,C,D,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<G> Choice6<A,B,C,D,E,G> |
Choice6.zip(Applicative<Fn1<? super F,? extends G>,Choice6<A,B,C,D,E,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<H> Choice7<A,B,C,D,E,F,H> |
Choice7.zip(Applicative<Fn1<? super G,? extends H>,Choice7<A,B,C,D,E,F,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<I> Choice8<A,B,C,D,E,F,G,I> |
Choice8.zip(Applicative<Fn1<? super H,? extends I>,Choice8<A,B,C,D,E,F,G,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Method and Description |
|---|---|
default CoProduct2<A,B,? extends CoProduct2<A,B,?>> |
CoProduct3.converge(Fn1<? super C,? extends CoProduct2<A,B,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
default CoProduct3<A,B,C,? extends CoProduct3<A,B,C,?>> |
CoProduct4.converge(Fn1<? super D,? extends CoProduct3<A,B,C,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
default CoProduct4<A,B,C,D,? extends CoProduct4<A,B,C,D,?>> |
CoProduct5.converge(Fn1<? super E,? extends CoProduct4<A,B,C,D,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
default CoProduct5<A,B,C,D,E,? extends CoProduct5<A,B,C,D,E,?>> |
CoProduct6.converge(Fn1<? super F,? extends CoProduct5<A,B,C,D,E,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
default CoProduct6<A,B,C,D,E,F,? extends CoProduct6<A,B,C,D,E,F,?>> |
CoProduct7.converge(Fn1<? super G,? extends CoProduct6<A,B,C,D,E,F,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
default CoProduct7<A,B,C,D,E,F,G,? extends CoProduct7<A,B,C,D,E,F,G,?>> |
CoProduct8.converge(Fn1<? super H,? extends CoProduct7<A,B,C,D,E,F,G,?>> convergenceFn)
Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier
possible type.
|
default <R> R |
CoProduct2.embed(Fn1<? super CP2,? extends R> aFn,
Fn1<? super CP2,? extends R> bFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct2.embed(Fn1<? super CP2,? extends R> aFn,
Fn1<? super CP2,? extends R> bFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct3.embed(Fn1<? super CP3,? extends R> aFn,
Fn1<? super CP3,? extends R> bFn,
Fn1<? super CP3,? extends R> cFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct3.embed(Fn1<? super CP3,? extends R> aFn,
Fn1<? super CP3,? extends R> bFn,
Fn1<? super CP3,? extends R> cFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct3.embed(Fn1<? super CP3,? extends R> aFn,
Fn1<? super CP3,? extends R> bFn,
Fn1<? super CP3,? extends R> cFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct4.embed(Fn1<? super CP4,? extends R> aFn,
Fn1<? super CP4,? extends R> bFn,
Fn1<? super CP4,? extends R> cFn,
Fn1<? super CP4,? extends R> dFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct4.embed(Fn1<? super CP4,? extends R> aFn,
Fn1<? super CP4,? extends R> bFn,
Fn1<? super CP4,? extends R> cFn,
Fn1<? super CP4,? extends R> dFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct4.embed(Fn1<? super CP4,? extends R> aFn,
Fn1<? super CP4,? extends R> bFn,
Fn1<? super CP4,? extends R> cFn,
Fn1<? super CP4,? extends R> dFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct4.embed(Fn1<? super CP4,? extends R> aFn,
Fn1<? super CP4,? extends R> bFn,
Fn1<? super CP4,? extends R> cFn,
Fn1<? super CP4,? extends R> dFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct5.embed(Fn1<? super CP5,? extends R> aFn,
Fn1<? super CP5,? extends R> bFn,
Fn1<? super CP5,? extends R> cFn,
Fn1<? super CP5,? extends R> dFn,
Fn1<? super CP5,? extends R> eFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct5.embed(Fn1<? super CP5,? extends R> aFn,
Fn1<? super CP5,? extends R> bFn,
Fn1<? super CP5,? extends R> cFn,
Fn1<? super CP5,? extends R> dFn,
Fn1<? super CP5,? extends R> eFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct5.embed(Fn1<? super CP5,? extends R> aFn,
Fn1<? super CP5,? extends R> bFn,
Fn1<? super CP5,? extends R> cFn,
Fn1<? super CP5,? extends R> dFn,
Fn1<? super CP5,? extends R> eFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct5.embed(Fn1<? super CP5,? extends R> aFn,
Fn1<? super CP5,? extends R> bFn,
Fn1<? super CP5,? extends R> cFn,
Fn1<? super CP5,? extends R> dFn,
Fn1<? super CP5,? extends R> eFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct5.embed(Fn1<? super CP5,? extends R> aFn,
Fn1<? super CP5,? extends R> bFn,
Fn1<? super CP5,? extends R> cFn,
Fn1<? super CP5,? extends R> dFn,
Fn1<? super CP5,? extends R> eFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct6.embed(Fn1<? super CP6,? extends R> aFn,
Fn1<? super CP6,? extends R> bFn,
Fn1<? super CP6,? extends R> cFn,
Fn1<? super CP6,? extends R> dFn,
Fn1<? super CP6,? extends R> eFn,
Fn1<? super CP6,? extends R> fFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct6.embed(Fn1<? super CP6,? extends R> aFn,
Fn1<? super CP6,? extends R> bFn,
Fn1<? super CP6,? extends R> cFn,
Fn1<? super CP6,? extends R> dFn,
Fn1<? super CP6,? extends R> eFn,
Fn1<? super CP6,? extends R> fFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct6.embed(Fn1<? super CP6,? extends R> aFn,
Fn1<? super CP6,? extends R> bFn,
Fn1<? super CP6,? extends R> cFn,
Fn1<? super CP6,? extends R> dFn,
Fn1<? super CP6,? extends R> eFn,
Fn1<? super CP6,? extends R> fFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct6.embed(Fn1<? super CP6,? extends R> aFn,
Fn1<? super CP6,? extends R> bFn,
Fn1<? super CP6,? extends R> cFn,
Fn1<? super CP6,? extends R> dFn,
Fn1<? super CP6,? extends R> eFn,
Fn1<? super CP6,? extends R> fFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct6.embed(Fn1<? super CP6,? extends R> aFn,
Fn1<? super CP6,? extends R> bFn,
Fn1<? super CP6,? extends R> cFn,
Fn1<? super CP6,? extends R> dFn,
Fn1<? super CP6,? extends R> eFn,
Fn1<? super CP6,? extends R> fFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct6.embed(Fn1<? super CP6,? extends R> aFn,
Fn1<? super CP6,? extends R> bFn,
Fn1<? super CP6,? extends R> cFn,
Fn1<? super CP6,? extends R> dFn,
Fn1<? super CP6,? extends R> eFn,
Fn1<? super CP6,? extends R> fFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct7.embed(Fn1<? super CP7,? extends R> aFn,
Fn1<? super CP7,? extends R> bFn,
Fn1<? super CP7,? extends R> cFn,
Fn1<? super CP7,? extends R> dFn,
Fn1<? super CP7,? extends R> eFn,
Fn1<? super CP7,? extends R> fFn,
Fn1<? super CP7,? extends R> gFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct7.embed(Fn1<? super CP7,? extends R> aFn,
Fn1<? super CP7,? extends R> bFn,
Fn1<? super CP7,? extends R> cFn,
Fn1<? super CP7,? extends R> dFn,
Fn1<? super CP7,? extends R> eFn,
Fn1<? super CP7,? extends R> fFn,
Fn1<? super CP7,? extends R> gFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct7.embed(Fn1<? super CP7,? extends R> aFn,
Fn1<? super CP7,? extends R> bFn,
Fn1<? super CP7,? extends R> cFn,
Fn1<? super CP7,? extends R> dFn,
Fn1<? super CP7,? extends R> eFn,
Fn1<? super CP7,? extends R> fFn,
Fn1<? super CP7,? extends R> gFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct7.embed(Fn1<? super CP7,? extends R> aFn,
Fn1<? super CP7,? extends R> bFn,
Fn1<? super CP7,? extends R> cFn,
Fn1<? super CP7,? extends R> dFn,
Fn1<? super CP7,? extends R> eFn,
Fn1<? super CP7,? extends R> fFn,
Fn1<? super CP7,? extends R> gFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct7.embed(Fn1<? super CP7,? extends R> aFn,
Fn1<? super CP7,? extends R> bFn,
Fn1<? super CP7,? extends R> cFn,
Fn1<? super CP7,? extends R> dFn,
Fn1<? super CP7,? extends R> eFn,
Fn1<? super CP7,? extends R> fFn,
Fn1<? super CP7,? extends R> gFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct7.embed(Fn1<? super CP7,? extends R> aFn,
Fn1<? super CP7,? extends R> bFn,
Fn1<? super CP7,? extends R> cFn,
Fn1<? super CP7,? extends R> dFn,
Fn1<? super CP7,? extends R> eFn,
Fn1<? super CP7,? extends R> fFn,
Fn1<? super CP7,? extends R> gFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct7.embed(Fn1<? super CP7,? extends R> aFn,
Fn1<? super CP7,? extends R> bFn,
Fn1<? super CP7,? extends R> cFn,
Fn1<? super CP7,? extends R> dFn,
Fn1<? super CP7,? extends R> eFn,
Fn1<? super CP7,? extends R> fFn,
Fn1<? super CP7,? extends R> gFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct8.embed(Fn1<? super CP8,? extends R> aFn,
Fn1<? super CP8,? extends R> bFn,
Fn1<? super CP8,? extends R> cFn,
Fn1<? super CP8,? extends R> dFn,
Fn1<? super CP8,? extends R> eFn,
Fn1<? super CP8,? extends R> fFn,
Fn1<? super CP8,? extends R> gFn,
Fn1<? super CP8,? extends R> hFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct8.embed(Fn1<? super CP8,? extends R> aFn,
Fn1<? super CP8,? extends R> bFn,
Fn1<? super CP8,? extends R> cFn,
Fn1<? super CP8,? extends R> dFn,
Fn1<? super CP8,? extends R> eFn,
Fn1<? super CP8,? extends R> fFn,
Fn1<? super CP8,? extends R> gFn,
Fn1<? super CP8,? extends R> hFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct8.embed(Fn1<? super CP8,? extends R> aFn,
Fn1<? super CP8,? extends R> bFn,
Fn1<? super CP8,? extends R> cFn,
Fn1<? super CP8,? extends R> dFn,
Fn1<? super CP8,? extends R> eFn,
Fn1<? super CP8,? extends R> fFn,
Fn1<? super CP8,? extends R> gFn,
Fn1<? super CP8,? extends R> hFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct8.embed(Fn1<? super CP8,? extends R> aFn,
Fn1<? super CP8,? extends R> bFn,
Fn1<? super CP8,? extends R> cFn,
Fn1<? super CP8,? extends R> dFn,
Fn1<? super CP8,? extends R> eFn,
Fn1<? super CP8,? extends R> fFn,
Fn1<? super CP8,? extends R> gFn,
Fn1<? super CP8,? extends R> hFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct8.embed(Fn1<? super CP8,? extends R> aFn,
Fn1<? super CP8,? extends R> bFn,
Fn1<? super CP8,? extends R> cFn,
Fn1<? super CP8,? extends R> dFn,
Fn1<? super CP8,? extends R> eFn,
Fn1<? super CP8,? extends R> fFn,
Fn1<? super CP8,? extends R> gFn,
Fn1<? super CP8,? extends R> hFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct8.embed(Fn1<? super CP8,? extends R> aFn,
Fn1<? super CP8,? extends R> bFn,
Fn1<? super CP8,? extends R> cFn,
Fn1<? super CP8,? extends R> dFn,
Fn1<? super CP8,? extends R> eFn,
Fn1<? super CP8,? extends R> fFn,
Fn1<? super CP8,? extends R> gFn,
Fn1<? super CP8,? extends R> hFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct8.embed(Fn1<? super CP8,? extends R> aFn,
Fn1<? super CP8,? extends R> bFn,
Fn1<? super CP8,? extends R> cFn,
Fn1<? super CP8,? extends R> dFn,
Fn1<? super CP8,? extends R> eFn,
Fn1<? super CP8,? extends R> fFn,
Fn1<? super CP8,? extends R> gFn,
Fn1<? super CP8,? extends R> hFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
default <R> R |
CoProduct8.embed(Fn1<? super CP8,? extends R> aFn,
Fn1<? super CP8,? extends R> bFn,
Fn1<? super CP8,? extends R> cFn,
Fn1<? super CP8,? extends R> dFn,
Fn1<? super CP8,? extends R> eFn,
Fn1<? super CP8,? extends R> fFn,
Fn1<? super CP8,? extends R> gFn,
Fn1<? super CP8,? extends R> hFn)
Embed this coproduct inside another value; that is, given morphisms from this coproduct to
R, apply
the appropriate morphism to this coproduct as a whole. |
<R> R |
CoProduct2.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct2.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct3.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct3.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct3.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct4.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct4.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct4.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct4.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct5.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct5.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct5.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct5.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct5.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct6.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct6.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct6.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct6.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct6.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct6.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct7.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct7.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct7.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct7.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct7.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct7.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct7.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct8.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn,
Fn1<? super H,? extends R> hFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct8.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn,
Fn1<? super H,? extends R> hFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct8.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn,
Fn1<? super H,? extends R> hFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct8.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn,
Fn1<? super H,? extends R> hFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct8.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn,
Fn1<? super H,? extends R> hFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct8.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn,
Fn1<? super H,? extends R> hFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct8.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn,
Fn1<? super H,? extends R> hFn)
Type-safe convergence requiring a match against all potential types.
|
<R> R |
CoProduct8.match(Fn1<? super A,? extends R> aFn,
Fn1<? super B,? extends R> bFn,
Fn1<? super C,? extends R> cFn,
Fn1<? super D,? extends R> dFn,
Fn1<? super E,? extends R> eFn,
Fn1<? super F,? extends R> fFn,
Fn1<? super G,? extends R> gFn,
Fn1<? super H,? extends R> hFn)
Type-safe convergence requiring a match against all potential types.
|
| Modifier and Type | Method and Description |
|---|---|
<_1Prime,_2Prime> |
Tuple2.biMap(Fn1<? super _1,? extends _1Prime> lFn,
Fn1<? super _2,? extends _2Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_1Prime,_2Prime> |
Tuple2.biMap(Fn1<? super _1,? extends _1Prime> lFn,
Fn1<? super _2,? extends _2Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_2Prime,_3Prime> |
Tuple3.biMap(Fn1<? super _2,? extends _2Prime> lFn,
Fn1<? super _3,? extends _3Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_2Prime,_3Prime> |
Tuple3.biMap(Fn1<? super _2,? extends _2Prime> lFn,
Fn1<? super _3,? extends _3Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_3Prime,_4Prime> |
Tuple4.biMap(Fn1<? super _3,? extends _3Prime> lFn,
Fn1<? super _4,? extends _4Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_3Prime,_4Prime> |
Tuple4.biMap(Fn1<? super _3,? extends _3Prime> lFn,
Fn1<? super _4,? extends _4Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_4Prime,_5Prime> |
Tuple5.biMap(Fn1<? super _4,? extends _4Prime> lFn,
Fn1<? super _5,? extends _5Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_4Prime,_5Prime> |
Tuple5.biMap(Fn1<? super _4,? extends _4Prime> lFn,
Fn1<? super _5,? extends _5Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_5Prime,_6Prime> |
Tuple6.biMap(Fn1<? super _5,? extends _5Prime> lFn,
Fn1<? super _6,? extends _6Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_5Prime,_6Prime> |
Tuple6.biMap(Fn1<? super _5,? extends _5Prime> lFn,
Fn1<? super _6,? extends _6Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_6Prime,_7Prime> |
Tuple7.biMap(Fn1<? super _6,? extends _6Prime> lFn,
Fn1<? super _7,? extends _7Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_6Prime,_7Prime> |
Tuple7.biMap(Fn1<? super _6,? extends _6Prime> lFn,
Fn1<? super _7,? extends _7Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_7Prime,_8Prime> |
Tuple8.biMap(Fn1<? super _7,? extends _7Prime> lFn,
Fn1<? super _8,? extends _8Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_7Prime,_8Prime> |
Tuple8.biMap(Fn1<? super _7,? extends _7Prime> lFn,
Fn1<? super _8,? extends _8Prime> rFn)
Dually map covariantly over both the left and right parameters.
|
<_1Prime> Tuple2<_1Prime,_2> |
Tuple2.biMapL(Fn1<? super _1,? extends _1Prime> fn)
Covariantly map over the left parameter.
|
<_2Prime> Tuple3<_1,_2Prime,_3> |
Tuple3.biMapL(Fn1<? super _2,? extends _2Prime> fn)
Covariantly map over the left parameter.
|
<_3Prime> Tuple4<_1,_2,_3Prime,_4> |
Tuple4.biMapL(Fn1<? super _3,? extends _3Prime> fn)
Covariantly map over the left parameter.
|
<_4Prime> Tuple5<_1,_2,_3,_4Prime,_5> |
Tuple5.biMapL(Fn1<? super _4,? extends _4Prime> fn)
Covariantly map over the left parameter.
|
<_5Prime> Tuple6<_1,_2,_3,_4,_5Prime,_6> |
Tuple6.biMapL(Fn1<? super _5,? extends _5Prime> fn)
Covariantly map over the left parameter.
|
<_6Prime> Tuple7<_1,_2,_3,_4,_5,_6Prime,_7> |
Tuple7.biMapL(Fn1<? super _6,? extends _6Prime> fn)
Covariantly map over the left parameter.
|
<_7Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7Prime,_8> |
Tuple8.biMapL(Fn1<? super _7,? extends _7Prime> fn)
Covariantly map over the left parameter.
|
<_2Prime> Tuple2<_1,_2Prime> |
Tuple2.biMapR(Fn1<? super _2,? extends _2Prime> fn)
Covariantly map over the right parameter.
|
<_3Prime> Tuple3<_1,_2,_3Prime> |
Tuple3.biMapR(Fn1<? super _3,? extends _3Prime> fn)
Covariantly map over the right parameter.
|
<_4Prime> Tuple4<_1,_2,_3,_4Prime> |
Tuple4.biMapR(Fn1<? super _4,? extends _4Prime> fn)
Covariantly map over the right parameter.
|
<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime> |
Tuple5.biMapR(Fn1<? super _5,? extends _5Prime> fn)
Covariantly map over the right parameter.
|
<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime> |
Tuple6.biMapR(Fn1<? super _6,? extends _6Prime> fn)
Covariantly map over the right parameter.
|
<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime> |
Tuple7.biMapR(Fn1<? super _7,? extends _7Prime> fn)
Covariantly map over the right parameter.
|
<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime> |
Tuple8.biMapR(Fn1<? super _8,? extends _8Prime> fn)
Covariantly map over the right parameter.
|
Tuple2<_1,_2> |
Tuple2.censor(Fn1<? super _1,? extends _1> fn)
Update the accumulated state.
|
<_1Prime> SingletonHList<_1Prime> |
SingletonHList.flatMap(Fn1<? super _1,? extends Monad<_1Prime,SingletonHList<?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<_2Prime> Tuple2<_1,_2Prime> |
Tuple2.flatMap(Fn1<? super _2,? extends Monad<_2Prime,Tuple2<_1,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<_3Prime> Tuple3<_1,_2,_3Prime> |
Tuple3.flatMap(Fn1<? super _3,? extends Monad<_3Prime,Tuple3<_1,_2,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<_4Prime> Tuple4<_1,_2,_3,_4Prime> |
Tuple4.flatMap(Fn1<? super _4,? extends Monad<_4Prime,Tuple4<_1,_2,_3,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime> |
Tuple5.flatMap(Fn1<? super _5,? extends Monad<_5Prime,Tuple5<_1,_2,_3,_4,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime> |
Tuple6.flatMap(Fn1<? super _6,? extends Monad<_6Prime,Tuple6<_1,_2,_3,_4,_5,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime> |
Tuple7.flatMap(Fn1<? super _7,? extends Monad<_7Prime,Tuple7<_1,_2,_3,_4,_5,_6,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime> |
Tuple8.flatMap(Fn1<? super _8,? extends Monad<_8Prime,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<_1Prime> SingletonHList<_1Prime> |
SingletonHList.fmap(Fn1<? super _1,? extends _1Prime> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<_2Prime> Tuple2<_1,_2Prime> |
Tuple2.fmap(Fn1<? super _2,? extends _2Prime> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<_3Prime> Tuple3<_1,_2,_3Prime> |
Tuple3.fmap(Fn1<? super _3,? extends _3Prime> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<_4Prime> Tuple4<_1,_2,_3,_4Prime> |
Tuple4.fmap(Fn1<? super _4,? extends _4Prime> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime> |
Tuple5.fmap(Fn1<? super _5,? extends _5Prime> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime> |
Tuple6.fmap(Fn1<? super _6,? extends _6Prime> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime> |
Tuple7.fmap(Fn1<? super _7,? extends _7Prime> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime> |
Tuple8.fmap(Fn1<? super _8,? extends _8Prime> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<R> R |
SingletonHList.into(Fn1<? super _1,? extends R> fn)
Apply
HList.HCons.head() to fn and return the result. |
<_3> Tuple2<_1,Tuple2<_2,_3>> |
Tuple2.listens(Fn1<? super _1,? extends _3> fn)
Map the accumulation into a value and pair it with the current output.
|
<_1Prime> SingletonHList<_1Prime> |
SingletonHList.trampolineM(Fn1<? super _1,? extends MonadRec<RecursiveResult<_1,_1Prime>,SingletonHList<?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<_2Prime> Tuple2<_1,_2Prime> |
Tuple2.trampolineM(Fn1<? super _2,? extends MonadRec<RecursiveResult<_2,_2Prime>,Tuple2<_1,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<_3Prime> Tuple3<_1,_2,_3Prime> |
Tuple3.trampolineM(Fn1<? super _3,? extends MonadRec<RecursiveResult<_3,_3Prime>,Tuple3<_1,_2,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<_4Prime> Tuple4<_1,_2,_3,_4Prime> |
Tuple4.trampolineM(Fn1<? super _4,? extends MonadRec<RecursiveResult<_4,_4Prime>,Tuple4<_1,_2,_3,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime> |
Tuple5.trampolineM(Fn1<? super _5,? extends MonadRec<RecursiveResult<_5,_5Prime>,Tuple5<_1,_2,_3,_4,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime> |
Tuple6.trampolineM(Fn1<? super _6,? extends MonadRec<RecursiveResult<_6,_6Prime>,Tuple6<_1,_2,_3,_4,_5,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime> |
Tuple7.trampolineM(Fn1<? super _7,? extends MonadRec<RecursiveResult<_7,_7Prime>,Tuple7<_1,_2,_3,_4,_5,_6,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime> |
Tuple8.trampolineM(Fn1<? super _8,? extends MonadRec<RecursiveResult<_8,_8Prime>,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,SingletonHList<?>>,AppTrav extends Applicative<TravB,App>> |
SingletonHList.traverse(Fn1<? super _1,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,SingletonHList<?>>,AppTrav extends Applicative<TravB,App>> |
SingletonHList.traverse(Fn1<? super _1,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_2Prime,App extends Applicative<?,App>,TravB extends Traversable<_2Prime,Tuple2<_1,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple2.traverse(Fn1<? super _2,? extends Applicative<_2Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_2Prime,App extends Applicative<?,App>,TravB extends Traversable<_2Prime,Tuple2<_1,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple2.traverse(Fn1<? super _2,? extends Applicative<_2Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_3Prime,App extends Applicative<?,App>,TravB extends Traversable<_3Prime,Tuple3<_1,_2,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple3.traverse(Fn1<? super _3,? extends Applicative<_3Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_3Prime,App extends Applicative<?,App>,TravB extends Traversable<_3Prime,Tuple3<_1,_2,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple3.traverse(Fn1<? super _3,? extends Applicative<_3Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_4Prime,App extends Applicative<?,App>,TravB extends Traversable<_4Prime,Tuple4<_1,_2,_3,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple4.traverse(Fn1<? super _4,? extends Applicative<_4Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_4Prime,App extends Applicative<?,App>,TravB extends Traversable<_4Prime,Tuple4<_1,_2,_3,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple4.traverse(Fn1<? super _4,? extends Applicative<_4Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_5Prime,App extends Applicative<?,App>,TravB extends Traversable<_5Prime,Tuple5<_1,_2,_3,_4,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple5.traverse(Fn1<? super _5,? extends Applicative<_5Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_5Prime,App extends Applicative<?,App>,TravB extends Traversable<_5Prime,Tuple5<_1,_2,_3,_4,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple5.traverse(Fn1<? super _5,? extends Applicative<_5Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_6Prime,App extends Applicative<?,App>,TravB extends Traversable<_6Prime,Tuple6<_1,_2,_3,_4,_5,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple6.traverse(Fn1<? super _6,? extends Applicative<_6Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_6Prime,App extends Applicative<?,App>,TravB extends Traversable<_6Prime,Tuple6<_1,_2,_3,_4,_5,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple6.traverse(Fn1<? super _6,? extends Applicative<_6Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_7Prime,App extends Applicative<?,App>,TravB extends Traversable<_7Prime,Tuple7<_1,_2,_3,_4,_5,_6,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple7.traverse(Fn1<? super _7,? extends Applicative<_7Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_7Prime,App extends Applicative<?,App>,TravB extends Traversable<_7Prime,Tuple7<_1,_2,_3,_4,_5,_6,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple7.traverse(Fn1<? super _7,? extends Applicative<_7Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_8Prime,App extends Applicative<?,App>,TravB extends Traversable<_8Prime,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple8.traverse(Fn1<? super _8,? extends Applicative<_8Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<_8Prime,App extends Applicative<?,App>,TravB extends Traversable<_8Prime,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>,AppTrav extends Applicative<TravB,App>> |
Tuple8.traverse(Fn1<? super _8,? extends Applicative<_8Prime,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
| Modifier and Type | Method and Description |
|---|---|
<_1Prime> Lazy<SingletonHList<_1Prime>> |
SingletonHList.lazyZip(Lazy<? extends Applicative<Fn1<? super _1,? extends _1Prime>,SingletonHList<?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<_2Prime> Lazy<Tuple2<_1,_2Prime>> |
Tuple2.lazyZip(Lazy<? extends Applicative<Fn1<? super _2,? extends _2Prime>,Tuple2<_1,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<_3Prime> Lazy<Tuple3<_1,_2,_3Prime>> |
Tuple3.lazyZip(Lazy<? extends Applicative<Fn1<? super _3,? extends _3Prime>,Tuple3<_1,_2,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<_4Prime> Lazy<Tuple4<_1,_2,_3,_4Prime>> |
Tuple4.lazyZip(Lazy<? extends Applicative<Fn1<? super _4,? extends _4Prime>,Tuple4<_1,_2,_3,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<_5Prime> Lazy<Tuple5<_1,_2,_3,_4,_5Prime>> |
Tuple5.lazyZip(Lazy<? extends Applicative<Fn1<? super _5,? extends _5Prime>,Tuple5<_1,_2,_3,_4,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<_6Prime> Lazy<Tuple6<_1,_2,_3,_4,_5,_6Prime>> |
Tuple6.lazyZip(Lazy<? extends Applicative<Fn1<? super _6,? extends _6Prime>,Tuple6<_1,_2,_3,_4,_5,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<_7Prime> Lazy<Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>> |
Tuple7.lazyZip(Lazy<? extends Applicative<Fn1<? super _7,? extends _7Prime>,Tuple7<_1,_2,_3,_4,_5,_6,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<_8Prime> Lazy<Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>> |
Tuple8.lazyZip(Lazy<? extends Applicative<Fn1<? super _8,? extends _8Prime>,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<_1Prime> SingletonHList<_1Prime> |
SingletonHList.zip(Applicative<Fn1<? super _1,? extends _1Prime>,SingletonHList<?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<_2Prime> Tuple2<_1,_2Prime> |
Tuple2.zip(Applicative<Fn1<? super _2,? extends _2Prime>,Tuple2<_1,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<_3Prime> Tuple3<_1,_2,_3Prime> |
Tuple3.zip(Applicative<Fn1<? super _3,? extends _3Prime>,Tuple3<_1,_2,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<_4Prime> Tuple4<_1,_2,_3,_4Prime> |
Tuple4.zip(Applicative<Fn1<? super _4,? extends _4Prime>,Tuple4<_1,_2,_3,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime> |
Tuple5.zip(Applicative<Fn1<? super _5,? extends _5Prime>,Tuple5<_1,_2,_3,_4,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime> |
Tuple6.zip(Applicative<Fn1<? super _6,? extends _6Prime>,Tuple6<_1,_2,_3,_4,_5,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime> |
Tuple7.zip(Applicative<Fn1<? super _7,? extends _7Prime>,Tuple7<_1,_2,_3,_4,_5,_6,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime> |
Tuple8.zip(Applicative<Fn1<? super _8,? extends _8Prime>,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
Effect<A>
A function returning "no result", and therefore only useful as a side-effect.
|
interface |
Fn0<A>
|
interface |
Fn2<A,B,C>
A function taking two arguments.
|
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 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 Fn1<B,C> |
Fn2.apply(A a)
Partially apply this function by passing its first argument.
|
default Fn1<C,D> |
Fn3.apply(A a,
B b)
Partially apply this function by taking its first two arguments.
|
default Fn1<D,E> |
Fn4.apply(A a,
B b,
C c)
Partially apply this function by taking its first three arguments.
|
default Fn1<E,F> |
Fn5.apply(A a,
B b,
C c,
D d)
Partially apply this function by taking its first four arguments.
|
default Fn1<F,G> |
Fn6.apply(A a,
B b,
C c,
D d,
E e)
Partially apply this function by taking its first five arguments.
|
default Fn1<G,H> |
Fn7.apply(A a,
B b,
C c,
D d,
E e,
F f)
Partially apply this function by taking its first six arguments.
|
default Fn1<H,I> |
Fn8.apply(A a,
B b,
C c,
D d,
E e,
F f,
G g)
Partially apply this function by taking its first seven arguments.
|
default Fn1<A,Tuple2<A,B>> |
Fn1.carry()
Pair the covariantly-positioned carrier type with the contravariantly-positioned carrier type.
|
default <C> Fn1<Tuple2<C,A>,Tuple2<C,B>> |
Fn1.cartesian()
Pair a value with the input to this function, and preserve the paired value through to the output.
|
default Fn1<A,B> |
Fn1.censor(Fn1<? super A,? extends A> fn)
Update the accumulated state.
|
default Fn1<B,C> |
Fn2.checkedApply(A a)
Invoke this function with the given argument, potentially throwing any
Throwable. |
default Fn1<C,D> |
Fn3.checkedApply(A a,
B b) |
default Fn1<D,E> |
Fn4.checkedApply(A a,
B b,
C c) |
default Fn1<E,F> |
Fn5.checkedApply(A a,
B b,
C c,
D d) |
default Fn1<F,G> |
Fn6.checkedApply(A a,
B b,
C c,
D d,
E e) |
default Fn1<G,H> |
Fn7.checkedApply(A a,
B b,
C c,
D d,
E e,
F f) |
default Fn1<H,I> |
Fn8.checkedApply(A a,
B b,
C c,
D d,
E e,
F f,
G g) |
default Fn1<A,Choice2<A,B>> |
Fn1.choose()
Choose between a successful result
b or returning back the input, a. |
default <C> Fn1<Choice2<C,A>,Choice2<C,B>> |
Fn1.cocartesian()
Choose between either applying this function or returning back a different result altogether.
|
default <Z> Fn1<Z,B> |
Fn1.contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B. |
default <Z,C> Fn1<Z,C> |
Fn1.diMap(Fn1<? super Z,? extends A> lFn,
Fn1<? super B,? extends C> rFn)
Exercise both
diMapL and diMapR over this function in the same invocation. |
default <Z> Fn1<Z,B> |
Fn1.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 <C> Fn1<A,C> |
Fn1.diMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the return value of this function, producing a function that takes the same argument, and
produces the new result type.
|
default <C> Fn1<A,C> |
Fn1.discardL(Applicative<C,Fn1<A,?>> appB)
Sequence both this
Applicative and appB, discarding this Applicative's
result and returning appB. |
default <C> Fn1<A,B> |
Fn1.discardR(Applicative<C,Fn1<A,?>> appB)
Sequence both this
Applicative and appB, discarding appB's result and
returning this Applicative. |
default <C> Fn1<A,C> |
Fn1.flatMap(Fn1<? super B,? extends Monad<C,Fn1<A,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
default <C> Fn1<A,C> |
Fn1.fmap(Fn1<? super B,? extends C> f)
Also left-to-right composition (sadly).
|
static <A,B> Fn1<A,B> |
Fn1.fn1(Fn1<? super A,? extends B> fn)
Static factory method for avoid explicit casting when using method references as
Fn1s. |
static <A,B> Fn1<A,B> |
Fn1.fromFunction(Function<? super A,? extends B> function)
|
default <C> Fn1<A,Tuple2<B,C>> |
Fn1.listens(Fn1<? super A,? extends C> fn)
Map the accumulation into a value and pair it with the current output.
|
default Fn1<A,B> |
Fn1.local(Fn1<? super A,? extends A> fn)
Modify this
MonadReader's environment after reading it but before running the effect. |
default <C> Fn1<A,C> |
Fn1.pure(C c)
Lift the value
b into this applicative functor. |
default <C> Fn1<A,C> |
Fn1.trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Fn1<A,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
default Fn1<? super Product2<? extends A,? extends B>,C> |
Fn2.uncurry()
|
default <C> Fn1<A,C> |
Fn1.zip(Applicative<Fn1<? super B,? extends C>,Fn1<A,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
default <C> Fn1<A,C> |
Fn1.zip(Fn2<A,B,C> appFn) |
| Modifier and Type | Method and Description |
|---|---|
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) |
default <C> Lazy<Fn1<A,C>> |
Fn1.lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Fn1<A,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
static <A> Pure<Fn1<A,?>> |
Fn1.pureFn1()
|
| Modifier and Type | Method and Description |
|---|---|
default Fn1<A,B> |
Fn1.censor(Fn1<? super A,? extends A> fn)
Update the accumulated state.
|
default <Z> Fn5<Z,B,C,D,E,F> |
Fn5.contraMap(Fn1<? super Z,? extends A> fn) |
default <Z> Fn8<Z,B,C,D,E,F,G,H,I> |
Fn8.contraMap(Fn1<? super Z,? extends A> fn) |
default <Z> Fn4<Z,B,C,D,E> |
Fn4.contraMap(Fn1<? super Z,? extends A> fn) |
default <Z> Effect<Z> |
Effect.contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B. |
default <Z> Fn2<Z,B,C> |
Fn2.contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B. |
default <Z> Fn1<Z,B> |
Fn1.contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B. |
default <Z> Fn3<Z,B,C,D> |
Fn3.contraMap(Fn1<? super Z,? extends A> fn) |
default <Z> Fn6<Z,B,C,D,E,F,G> |
Fn6.contraMap(Fn1<? super Z,? extends A> fn) |
default <Z> Fn7<Z,B,C,D,E,F,G,H> |
Fn7.contraMap(Fn1<? super Z,? extends A> fn) |
static <A,B,C> Fn2<A,B,C> |
Fn2.curried(Fn1<A,Fn1<B,C>> curriedFn1)
|
static <A,B,C> Fn2<A,B,C> |
Fn2.curry(Fn1<? super Tuple2<A,B>,? extends C> uncurriedFn1)
|
default <Z,C> Fn1<Z,C> |
Fn1.diMap(Fn1<? super Z,? extends A> lFn,
Fn1<? super B,? extends C> rFn)
Exercise both
diMapL and diMapR over this function in the same invocation. |
default <Z,C> Fn1<Z,C> |
Fn1.diMap(Fn1<? super Z,? extends A> lFn,
Fn1<? super B,? extends C> rFn)
Exercise both
diMapL and diMapR over this function in the same invocation. |
default <Z> Fn5<Z,B,C,D,E,F> |
Fn5.diMapL(Fn1<? super Z,? extends A> fn) |
default <Z> Fn8<Z,B,C,D,E,F,G,H,I> |
Fn8.diMapL(Fn1<? super Z,? extends A> fn) |
default <Z> Fn4<Z,B,C,D,E> |
Fn4.diMapL(Fn1<? super Z,? extends A> fn) |
default <Z> Effect<Z> |
Effect.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 <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 <Z> Fn1<Z,B> |
Fn1.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 <Z> Fn3<Z,B,C,D> |
Fn3.diMapL(Fn1<? super Z,? extends A> fn) |
default <Z> Fn6<Z,B,C,D,E,F,G> |
Fn6.diMapL(Fn1<? super Z,? extends A> fn) |
default <Z> Fn7<Z,B,C,D,E,F,G,H> |
Fn7.diMapL(Fn1<? super Z,? extends A> fn) |
default <B> Fn0<B> |
Fn0.diMapR(Fn1<? super A,? extends B> fn) |
default <C> Fn1<A,C> |
Fn1.diMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the return value of this function, producing a function that takes the same argument, and
produces the new result type.
|
static <A> Effect<A> |
Effect.effect(Fn1<? super A,? extends IO<?>> fn)
|
default <B> Fn0<B> |
Fn0.flatMap(Fn1<? super A,? extends Monad<B,Fn1<Unit,?>>> f) |
default <C> Fn1<A,C> |
Fn1.flatMap(Fn1<? super B,? extends Monad<C,Fn1<A,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
default <B> Fn0<B> |
Fn0.fmap(Fn1<? super A,? extends B> f) |
default <C> Fn1<A,C> |
Fn1.fmap(Fn1<? super B,? extends C> f)
Also left-to-right composition (sadly).
|
static <A> Fn0<A> |
Fn0.fn0(Fn1<Unit,A> fn)
|
static <A,B> Fn1<A,B> |
Fn1.fn1(Fn1<? super A,? extends B> fn)
Static factory method for avoid explicit casting when using method references as
Fn1s. |
static <A,B,C,D> Fn3<A,B,C,D> |
Fn3.fn3(Fn1<A,Fn2<B,C,D>> curriedFn1)
|
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(Fn1<A,Fn4<B,C,D,E,F>> curriedFn1)
|
static <A,B,C,D,E,F,G> |
Fn6.fn6(Fn1<A,Fn5<B,C,D,E,F,G>> curriedFn1)
|
static <A,B,C,D,E,F,G,H> |
Fn7.fn7(Fn1<A,Fn6<B,C,D,E,F,G,H>> curriedFn1)
|
static <A,B,C,D,E,F,G,H,I> |
Fn8.fn8(Fn1<A,Fn7<B,C,D,E,F,G,H,I>> curriedFn1)
|
default <C> Fn1<A,Tuple2<B,C>> |
Fn1.listens(Fn1<? super A,? extends C> fn)
Map the accumulation into a value and pair it with the current output.
|
default Fn1<A,B> |
Fn1.local(Fn1<? super A,? extends A> fn)
Modify this
MonadReader's environment after reading it but before running the effect. |
default <C> Fn1<A,C> |
Fn1.trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Fn1<A,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
| Modifier and Type | Method and Description |
|---|---|
static <A,B,C> Fn2<A,B,C> |
Fn2.curried(Fn1<A,Fn1<B,C>> curriedFn1)
|
default <B> Fn0<B> |
Fn0.discardL(Applicative<B,Fn1<Unit,?>> appB) |
default <C> Fn1<A,C> |
Fn1.discardL(Applicative<C,Fn1<A,?>> appB)
Sequence both this
Applicative and appB, discarding this Applicative's
result and returning appB. |
default <B> Fn0<A> |
Fn0.discardR(Applicative<B,Fn1<Unit,?>> appB) |
default <C> Effect<A> |
Effect.discardR(Applicative<C,Fn1<A,?>> appB)
Sequence both this
Applicative and appB, discarding appB's result and
returning this Applicative. |
default <C> Fn1<A,B> |
Fn1.discardR(Applicative<C,Fn1<A,?>> appB)
Sequence both this
Applicative and appB, discarding appB's result and
returning this Applicative. |
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 <E> Fn3<A,B,C,D> |
Fn3.discardR(Applicative<E,Fn1<A,?>> appB) |
default <F> Fn4<A,B,C,D,E> |
Fn4.discardR(Applicative<F,Fn1<A,?>> appB) |
default <G> Fn5<A,B,C,D,E,F> |
Fn5.discardR(Applicative<G,Fn1<A,?>> appB) |
default <H> Fn6<A,B,C,D,E,F,G> |
Fn6.discardR(Applicative<H,Fn1<A,?>> appB) |
default <I> Fn7<A,B,C,D,E,F,G,H> |
Fn7.discardR(Applicative<I,Fn1<A,?>> appB) |
default <J> Fn8<A,B,C,D,E,F,G,H,I> |
Fn8.discardR(Applicative<J,Fn1<A,?>> appB) |
default <B> Fn0<B> |
Fn0.flatMap(Fn1<? super A,? extends Monad<B,Fn1<Unit,?>>> f) |
default <C> Fn1<A,C> |
Fn1.flatMap(Fn1<? super B,? extends Monad<C,Fn1<A,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
static <A,B,C,D> Fn3<A,B,C,D> |
Fn3.fn3(Fn2<A,B,Fn1<C,D>> curriedFn2)
|
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(Fn4<A,B,C,D,Fn1<E,F>> curriedFn4)
|
static <A,B,C,D,E,F,G> |
Fn6.fn6(Fn5<A,B,C,D,E,Fn1<F,G>> curriedFn5)
|
static <A,B,C,D,E,F,G,H> |
Fn7.fn7(Fn6<A,B,C,D,E,F,Fn1<G,H>> curriedFn6)
|
static <A,B,C,D,E,F,G,H,I> |
Fn8.fn8(Fn7<A,B,C,D,E,F,G,Fn1<H,I>> curriedFn7)
|
default <C> Lazy<Fn1<A,C>> |
Fn1.lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Fn1<A,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
default <C> Lazy<Fn1<A,C>> |
Fn1.lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Fn1<A,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
default <C> Fn1<A,C> |
Fn1.trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Fn1<A,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
default <B> Fn0<B> |
Fn0.zip(Applicative<Fn1<? super A,? extends B>,Fn1<Unit,?>> appFn) |
default <B> Fn0<B> |
Fn0.zip(Applicative<Fn1<? super A,? extends B>,Fn1<Unit,?>> appFn) |
default <C> Fn1<A,C> |
Fn1.zip(Applicative<Fn1<? super B,? extends C>,Fn1<A,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
default <C> Fn1<A,C> |
Fn1.zip(Applicative<Fn1<? super B,? extends C>,Fn1<A,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CatMaybes<A>
|
class |
Coalesce<L,R>
|
class |
Constantly<A,B>
A function that takes two arguments and always returns the first argument.
|
class |
Cycle<A>
Given an
Iterable, return an infinite Iterable that repeatedly cycles its elements, in
order. |
class |
Distinct<A>
|
class |
Downcast<A extends B,B>
Covariantly cast a value of type
B to a value of subtype A. |
class |
Empty<A>
A predicate that returns true if
as is empty; false otherwise. |
class |
Flatten<A>
|
class |
Force<A>
Deprecated.
in favor of
traversing into an IO and running it |
class |
Head<A>
|
class |
Id<A>
The identity function.
|
class |
Init<A>
|
class |
Inits<A>
|
class |
Last<A>
|
class |
Magnetize<A>
|
class |
Not<A>
Negate a predicate function.
|
class |
Occurrences<A>
|
class |
Repeat<A>
Given a value, return an infinite
Iterable that repeatedly iterates that value. |
class |
Reverse<A>
Given an
Iterable, return a reversed representation of that Iterable. |
class |
Size |
class |
Sort<A extends Comparable<A>>
|
class |
Tail<A>
Returns the tail of an
Iterable; the is, an Iterable of all the elements except for the
head element. |
class |
Tails<A>
|
class |
Uncons<A>
|
class |
Upcast<A extends B,B>
Upcast a value of type
B to a value of type A that B extends. |
| Modifier and Type | Method and Description |
|---|---|
static <A,B> Fn1<B,A> |
Constantly.constantly(A a) |
| Modifier and Type | Method and Description |
|---|---|
Boolean |
Not.checkedApply(Fn1<? super A,? extends Boolean> pred,
A a) |
static <A> Predicate<A> |
Not.not(Fn1<? super A,? extends Boolean> pred) |
static <A> Boolean |
Not.not(Fn1<? super A,? extends Boolean> pred,
A a) |
| Modifier and Type | Class and Description |
|---|---|
class |
All<A>
Eagerly apply a predicate to each element in an
Iterable, returning true if every element
satisfies the predicate, and false otherwise. |
class |
Alter<A>
|
class |
Any<A>
Eagerly apply a predicate to each element in an
Iterable, returning true if any element
satisfies the predicate, and false otherwise. |
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. |
class |
Both<A,B,C>
|
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. |
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. |
class |
Cons<A>
Prepend an element to an
Iterable. |
class |
Difference<A>
|
class |
Drop<A>
Lazily skip the first
n elements from an Iterable by returning an Iterable
that begins iteration after the nth element. |
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. |
class |
Eq<A>
Type-safe equality in function form; uses
Object.equals(java.lang.Object), not ==. |
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. |
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. |
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. |
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. |
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. |
class |
InGroupsOf<A>
Lazily group the
Iterable by returning an Iterable of smaller Iterables of
size k. |
class |
Intersperse<A>
Lazily inject the provided separator value between each value in the supplied
Iterable. |
class |
Into<A,B,C>
Given an
|
class |
Into1<A,B>
Given an
|
class |
Into3<A,B,C,D>
|
class |
Into4<A,B,C,D,E>
|
class |
Into5<A,B,C,D,E,F>
|
class |
Into6<A,B,C,D,E,F,G>
|
class |
Into7<A,B,C,D,E,F,G,H>
|
class |
Into8<A,B,C,D,E,F,G,H,I>
|
class |
Iterate<A>
|
class |
LazyRec<A,B>
|
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. |
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. |
class |
MagnetizeBy<A>
|
class |
Map<A,B>
Lazily apply a function to each element in an
Iterable, producing an Iterable of the mapped
results. |
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. |
class |
Peek<A,FA extends Functor<A,?>>
|
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 |
class |
PrependAll<A>
Lazily prepend each value with of the
Iterable with the supplied separator value. |
class |
ReduceLeft<A>
|
class |
ReduceRight<A>
|
class |
Replicate<A>
Produce an
Iterable of a value n times. |
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. |
class |
Slide<A>
|
class |
Snoc<A>
|
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. |
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. |
class |
Span<A>
|
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. |
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. |
class |
ToArray<A>
Write all the elements of an
Iterable directly into an array of the specified type. |
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. |
class |
ToMap<K,V,M extends Map<K,V>>
|
class |
Tupler2<A,B>
Creates a
Tuple2 from two values. |
class |
Unfoldr<A,B>
|
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. |
class |
Zip<A,B>
Zip together two
Iterables into a single Iterable of Tuple2<A, B>. |
| Modifier and Type | Method and Description |
|---|---|
static <A> Fn1<Iterable<A>,? extends Boolean> |
All.all(Fn1<? super A,? extends Boolean> predicate) |
static <A> Fn1<A,IO<A>> |
Alter.alter(Effect<? super A> effect) |
static <A extends AutoCloseable,B> |
AutoBracket.autoBracket(IO<A> io) |
static <A,B,C> Fn1<Fn1<? super A,? extends C>,Fn1<A,Tuple2<B,C>>> |
Both.both(Fn1<? super A,? extends B> f) |
static <A,B,C> Fn1<A,Tuple2<B,C>> |
Both.both(Fn1<? super A,? extends B> f,
Fn1<? super A,? extends C> g) |
static <A,B> Fn1<Iterable<B>,Iterable<Tuple2<A,B>>> |
CartesianProduct.cartesianProduct(Iterable<A> as) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Cons.cons(A a) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Difference.difference(Iterable<A> xs) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Drop.drop(int n) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
DropWhile.dropWhile(Fn1<? super A,? extends Boolean> predicate) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Filter.filter(Fn1<? super A,? extends Boolean> predicate) |
static <A> Fn1<Iterable<A>,Maybe<A>> |
Find.find(Fn1<? super A,? extends Boolean> predicate) |
static <K,V> Fn1<Iterable<V>,Map<K,List<V>>> |
GroupBy.groupBy(Fn1<? super V,? extends K> keyFn) |
static <A> Fn1<Iterable<A>,Iterable<Iterable<A>>> |
InGroupsOf.inGroupsOf(Integer k) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Intersperse.intersperse(A a) |
static <A,B,C> Fn1<Map.Entry<A,B>,C> |
Into.into(Fn2<? super A,? super B,? extends C> fn) |
static <A,B> Fn1<SingletonHList<A>,B> |
Into1.into1(Fn1<? super A,? extends B> fn) |
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,E> |
Into4.into4(Fn4<? super A,? super B,? super C,? super D,? extends E> fn) |
static <A,B,C,D,E,F> |
Into5.into5(Fn5<? super A,? super B,? super C,? super D,? super E,? extends F> fn) |
static <A,B,C,D,E,F,G> |
Into6.into6(Fn6<? super A,? super B,? super C,? super D,? super E,? super F,? extends G> fn) |
static <A,B,C,D,E,F,G,H> |
Into7.into7(Fn7<? super A,? super B,? super C,? super D,? super E,? super F,? super G,? extends H> fn) |
static <A,B,C,D,E,F,G,H,I> |
Into8.into8(Fn8<? super A,? super B,? super C,? super D,? super E,? super F,? super G,? super H,? extends I> fn) |
static <A> Fn1<A,Iterable<A>> |
Iterate.iterate(Fn1<? super A,? extends A> fn) |
static <A> Fn1<Iterable<A>,Iterable<Iterable<A>>> |
MagnetizeBy.magnetizeBy(Fn2<? super A,? super A,? extends Boolean> predicate) |
static <A,B> Fn1<Iterable<A>,Iterable<B>> |
Map.map(Fn1<? super A,? extends B> fn) |
static <A,B,C> Fn1<Iterable<A>,Tuple2<Iterable<B>,Iterable<C>>> |
Partition.partition(Fn1<? super A,? extends CoProduct2<B,C,?>> function) |
static <A,FA extends Functor<A,?>> |
Peek.peek(Fn1<? super A,? extends IO<?>> effect)
Deprecated.
|
static <A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>> |
Peek2.peek2(Fn1<? super A,? extends IO<?>> effectA,
Fn1<? super B,? extends IO<?>> effectB)
Deprecated.
|
static <A> Fn1<Iterable<A>,Iterable<A>> |
PrependAll.prependAll(A a) |
static <A> Fn1<Iterable<A>,Maybe<A>> |
ReduceLeft.reduceLeft(Fn2<? super A,? super A,? extends A> fn) |
static <A> Fn1<Iterable<A>,Maybe<A>> |
ReduceRight.reduceRight(Fn2<? super A,? super A,? extends A> fn) |
static <A> Fn1<A,Iterable<A>> |
Replicate.replicate(Integer n) |
static <A,App extends Applicative<?,App>,AppIterable extends Applicative<Iterable<A>,App>> |
Sequence.sequence(Iterable<? extends Applicative<A,App>> iterableApp) |
static <A,B,App extends Applicative<?,App>,AppMap extends Applicative<Map<A,B>,App>> |
Sequence.sequence(Map<A,? extends Applicative<B,App>> mapApp) |
static <A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>> |
Sequence.sequence(Traversable<? extends Applicative<A,App>,Trav> traversable) |
static <A> Fn1<Iterable<A>,Iterable<Iterable<A>>> |
Slide.slide(Integer k) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Snoc.snoc(A a) |
static <A,B extends Comparable<B>> |
SortBy.sortBy(Fn1<? super A,? extends B> fn) |
static <A> Fn1<Iterable<A>,List<A>> |
SortWith.sortWith(Comparator<? super A> comparator) |
static <A> Fn1<Iterable<A>,Tuple2<Iterable<A>,Iterable<A>>> |
Span.span(Fn1<? super A,? extends Boolean> predicate) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Take.take(int n) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
TakeWhile.takeWhile(Fn1<? super A,? extends Boolean> predicate) |
static <A> Fn1<Iterable<? extends A>,A[]> |
ToArray.toArray(Class<A[]> arrayType) |
static <A,C extends Collection<A>> |
ToCollection.toCollection(Fn0<C> cFn0) |
static <K,V,M extends Map<K,V>> |
ToMap.toMap(Fn0<M> mFn0) |
static <A,B> Fn1<B,Tuple2<A,B>> |
Tupler2.tupler(A a) |
static <A,B> Fn1<B,Iterable<A>> |
Unfoldr.unfoldr(Fn1<? super B,Maybe<Tuple2<A,B>>> fn) |
static <A> Fn1<IO<A>,IO<A>> |
Until.until(Fn1<? super A,? extends Boolean> pred) |
static <A,B> Fn1<Iterable<B>,Iterable<Tuple2<A,B>>> |
Zip.zip(Iterable<A> as) |
| Modifier and Type | Method and Description |
|---|---|
static <A extends AutoCloseable,B> |
AutoBracket.autoBracket(IO<A> io) |
static <A,B,C> Fn1<Fn1<? super A,? extends C>,Fn1<A,Tuple2<B,C>>> |
Both.both(Fn1<? super A,? extends B> f) |
static <A,B,C> Fn1<Fn1<? super A,? extends C>,Fn1<A,Tuple2<B,C>>> |
Both.both(Fn1<? super A,? extends B> f) |
static <A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>> |
Peek2.peek2(Fn1<? super A,? extends IO<?>> effectA)
Deprecated.
|
static <A,App extends Applicative<?,App>,AppIterable extends Applicative<Iterable<A>,App>> |
Sequence.sequence(Iterable<? extends Applicative<A,App>> iterableApp) |
static <A,B,App extends Applicative<?,App>,AppMap extends Applicative<Map<A,B>,App>> |
Sequence.sequence(Map<A,? extends Applicative<B,App>> mapApp) |
static <A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>> |
Sequence.sequence(Traversable<? extends Applicative<A,App>,Trav> traversable) |
| Modifier and Type | Method and Description |
|---|---|
static <A> Fn1<Iterable<A>,? extends Boolean> |
All.all(Fn1<? super A,? extends Boolean> predicate) |
static <A> Boolean |
All.all(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
static <A> Predicate<Iterable<A>> |
Any.any(Fn1<? super A,? extends Boolean> predicate) |
static <A> Boolean |
Any.any(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
static <A extends AutoCloseable,B> |
AutoBracket.autoBracket(IO<A> io,
Fn1<? super A,? extends IO<B>> bodyIO) |
static <A,B,C> Fn1<Fn1<? super A,? extends C>,Fn1<A,Tuple2<B,C>>> |
Both.both(Fn1<? super A,? extends B> f) |
static <A,B,C> Fn1<A,Tuple2<B,C>> |
Both.both(Fn1<? super A,? extends B> f,
Fn1<? super A,? extends C> g) |
static <A,B,C> Fn1<A,Tuple2<B,C>> |
Both.both(Fn1<? super A,? extends B> f,
Fn1<? super A,? extends C> g) |
static <A,B,C> Tuple2<B,C> |
Both.both(Fn1<? super A,? extends B> f,
Fn1<? super A,? extends C> g,
A a) |
static <A,B,C> Tuple2<B,C> |
Both.both(Fn1<? super A,? extends B> f,
Fn1<? super A,? extends C> g,
A a) |
Iterable<A> |
Iterate.checkedApply(Fn1<? super A,? extends A> fn,
A seed) |
Tuple2<B,C> |
Both.checkedApply(Fn1<? super A,? extends B> f,
Fn1<? super A,? extends C> g,
A a) |
Tuple2<B,C> |
Both.checkedApply(Fn1<? super A,? extends B> f,
Fn1<? super A,? extends C> g,
A a) |
Iterable<B> |
Map.checkedApply(Fn1<? super A,? extends B> fn,
Iterable<A> as) |
List<A> |
SortBy.checkedApply(Fn1<? super A,? extends B> fn,
Iterable<A> as) |
B |
Into1.checkedApply(Fn1<? super A,? extends B> fn,
SingletonHList<A> singletonHList) |
IO<A> |
Until.checkedApply(Fn1<? super A,? extends Boolean> pred,
IO<A> io) |
Boolean |
Any.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
Boolean |
All.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
Iterable<A> |
DropWhile.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
Maybe<A> |
Find.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
Iterable<A> |
TakeWhile.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
Tuple2<Iterable<A>,Iterable<A>> |
Span.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
Iterable<A> |
Filter.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
Tuple2<Iterable<B>,Iterable<C>> |
Partition.checkedApply(Fn1<? super A,? extends CoProduct2<B,C,?>> function,
Iterable<A> as) |
IO<A> |
Alter.checkedApply(Fn1<? super A,? extends IO<?>> effect,
A a) |
FA |
Peek.checkedApply(Fn1<? super A,? extends IO<?>> effect,
FA fa)
Deprecated.
|
FAB |
Peek2.checkedApply(Fn1<? super A,? extends IO<?>> effectA,
Fn1<? super B,? extends IO<?>> effectB,
FAB fab)
Deprecated.
|
FAB |
Peek2.checkedApply(Fn1<? super A,? extends IO<?>> effectA,
Fn1<? super B,? extends IO<?>> effectB,
FAB fab)
Deprecated.
|
Iterable<A> |
Unfoldr.checkedApply(Fn1<? super B,Maybe<Tuple2<A,B>>> fn,
B b) |
Map<K,List<V>> |
GroupBy.checkedApply(Fn1<? super V,? extends K> keyFn,
Iterable<V> vs) |
IO<B> |
AutoBracket.checkedApply(IO<A> io,
Fn1<? super A,? extends IO<B>> bodyIO) |
AppTrav |
Sequence.checkedApply(Traversable<? extends Applicative<A,App>,Trav> traversable,
Fn1<TravA,? extends AppTrav> pure) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
DropWhile.dropWhile(Fn1<? super A,? extends Boolean> predicate) |
static <A> Iterable<A> |
DropWhile.dropWhile(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Filter.filter(Fn1<? super A,? extends Boolean> predicate) |
static <A> Iterable<A> |
Filter.filter(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
static <A> Fn1<Iterable<A>,Maybe<A>> |
Find.find(Fn1<? super A,? extends Boolean> predicate) |
static <A> Maybe<A> |
Find.find(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
static <K,V> Fn1<Iterable<V>,Map<K,List<V>>> |
GroupBy.groupBy(Fn1<? super V,? extends K> keyFn) |
static <K,V> Map<K,List<V>> |
GroupBy.groupBy(Fn1<? super V,? extends K> keyFn,
Iterable<V> vs) |
static <A,B> Fn1<SingletonHList<A>,B> |
Into1.into1(Fn1<? super A,? extends B> fn) |
static <A,B> B |
Into1.into1(Fn1<? super A,? extends B> fn,
SingletonHList<A> singletonHList) |
static <A> Fn1<A,Iterable<A>> |
Iterate.iterate(Fn1<? super A,? extends A> fn) |
static <A> Iterable<A> |
Iterate.iterate(Fn1<? super A,? extends A> fn,
A seed) |
static <A,B> Fn1<Iterable<A>,Iterable<B>> |
Map.map(Fn1<? super A,? extends B> fn) |
static <A,B> Iterable<B> |
Map.map(Fn1<? super A,? extends B> fn,
Iterable<A> as) |
static <A,B,C> Fn1<Iterable<A>,Tuple2<Iterable<B>,Iterable<C>>> |
Partition.partition(Fn1<? super A,? extends CoProduct2<B,C,?>> function) |
static <A,B,C> Tuple2<Iterable<B>,Iterable<C>> |
Partition.partition(Fn1<? super A,? extends CoProduct2<B,C,?>> function,
Iterable<A> as) |
static <A,FA extends Functor<A,?>> |
Peek.peek(Fn1<? super A,? extends IO<?>> effect)
Deprecated.
|
static <A,FA extends Functor<A,?>> |
Peek.peek(Fn1<? super A,? extends IO<?>> effect,
FA fa)
Deprecated.
|
static <A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>> |
Peek2.peek2(Fn1<? super A,? extends IO<?>> effectA)
Deprecated.
|
static <A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>> |
Peek2.peek2(Fn1<? super A,? extends IO<?>> effectA,
Fn1<? super B,? extends IO<?>> effectB)
Deprecated.
|
static <A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>> |
Peek2.peek2(Fn1<? super A,? extends IO<?>> effectA,
Fn1<? super B,? extends IO<?>> effectB)
Deprecated.
|
static <A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>> |
Peek2.peek2(Fn1<? super A,? extends IO<?>> effectA,
Fn1<? super B,? extends IO<?>> effectB,
FAB fab)
Deprecated.
|
static <A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>> |
Peek2.peek2(Fn1<? super A,? extends IO<?>> effectA,
Fn1<? super B,? extends IO<?>> effectB,
FAB fab)
Deprecated.
|
static <A,App extends Applicative<?,App>,AppIterable extends Applicative<Iterable<A>,App>> |
Sequence.sequence(Iterable<? extends Applicative<A,App>> iterableApp,
Fn1<Iterable<A>,? extends AppIterable> pure) |
static <A,B,App extends Applicative<?,App>,AppMap extends Applicative<Map<A,B>,App>> |
Sequence.sequence(Map<A,? extends Applicative<B,App>> mapApp,
Fn1<Map<A,B>,? extends AppMap> pure) |
static <A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>> |
Sequence.sequence(Traversable<? extends Applicative<A,App>,Trav> traversable,
Fn1<TravA,? extends AppTrav> pure) |
static <A,B extends Comparable<B>> |
SortBy.sortBy(Fn1<? super A,? extends B> fn) |
static <A,B extends Comparable<B>> |
SortBy.sortBy(Fn1<? super A,? extends B> fn,
Iterable<A> as) |
static <A> Fn1<Iterable<A>,Tuple2<Iterable<A>,Iterable<A>>> |
Span.span(Fn1<? super A,? extends Boolean> predicate) |
static <A> Tuple2<Iterable<A>,Iterable<A>> |
Span.span(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
TakeWhile.takeWhile(Fn1<? super A,? extends Boolean> predicate) |
static <A> Iterable<A> |
TakeWhile.takeWhile(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
static <A,B> Fn1<B,Iterable<A>> |
Unfoldr.unfoldr(Fn1<? super B,Maybe<Tuple2<A,B>>> fn) |
static <A,B> Iterable<A> |
Unfoldr.unfoldr(Fn1<? super B,Maybe<Tuple2<A,B>>> fn,
B b) |
static <A> Fn1<IO<A>,IO<A>> |
Until.until(Fn1<? super A,? extends Boolean> pred) |
static <A> IO<A> |
Until.until(Fn1<? super A,? extends Boolean> pred,
IO<A> io) |
| 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
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 As, a starting value B, and a
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 As, a starting value B, and a
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
Iterables by applying a zipping function to the successive elements of each
Iterable until one of them runs out of elements. |
| Modifier and Type | Method and Description |
|---|---|
static <A,B> Fn1<Fn1<? super A,? extends IO<B>>,IO<B>> |
Bracket.bracket(IO<A> io,
Fn1<? super A,? extends IO<?>> cleanupIO) |
static <A extends Comparable<A>> |
Clamp.clamp(A lower,
A upper) |
static <A,B> Fn1<Iterable<A>,B> |
FoldLeft.foldLeft(Fn2<? super B,? super A,? extends B> fn,
B acc) |
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,C,App extends Applicative<?,App>,AppC extends Applicative<C,App>> |
LiftA2.liftA2(Fn2<? super A,? super B,? extends C> fn,
Applicative<A,App> appA) |
static <A,B> Fn1<Iterable<A>,Iterable<B>> |
ScanLeft.scanLeft(Fn2<? super B,? super A,? extends B> fn,
B b) |
static <A> Fn1<A,A> |
Times.times(Integer n,
Fn1<? super A,? extends A> fn) |
static <A,B,C> Fn1<Iterable<B>,Iterable<C>> |
ZipWith.zipWith(Fn2<? super A,? super B,? extends C> zipper,
Iterable<A> as) |
| Modifier and Type | Method and 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,B> Fn2<Fn1<? super A,? extends IO<?>>,Fn1<? super A,? extends IO<B>>,IO<B>> |
Bracket.bracket(IO<A> io) |
static <A,B> Fn1<Fn1<? super A,? extends IO<B>>,IO<B>> |
Bracket.bracket(IO<A> io,
Fn1<? super A,? extends IO<?>> cleanupIO) |
static <A> Fn2<Fn1<? super A,? extends A>,A,A> |
Times.times(Integer n) |
| Modifier and Type | Method and Description |
|---|---|
BiPredicate<A,A> |
LTBy.apply(Fn1<? super A,? extends B> compareFn) |
BiPredicate<A,A> |
CmpEqBy.apply(Fn1<? super A,? extends B> compareFn) |
BiPredicate<A,A> |
GTBy.apply(Fn1<? super A,? extends B> compareFn) |
BiPredicate<A,A> |
LTEBy.apply(Fn1<? super A,? extends B> compareFn) |
BiPredicate<A,A> |
GTEBy.apply(Fn1<? super A,? extends B> compareFn) |
Predicate<A> |
LTBy.apply(Fn1<? super A,? extends B> compareFn,
A y) |
Predicate<A> |
CmpEqBy.apply(Fn1<? super A,? extends B> compareFn,
A x) |
Predicate<A> |
GTBy.apply(Fn1<? super A,? extends B> compareFn,
A x) |
Predicate<A> |
LTEBy.apply(Fn1<? super A,? extends B> compareFn,
A y) |
Predicate<A> |
GTEBy.apply(Fn1<? super A,? extends B> compareFn,
A y) |
static <A,B> Fn1<Fn1<? super A,? extends IO<B>>,IO<B>> |
Bracket.bracket(IO<A> io,
Fn1<? super A,? extends IO<?>> cleanupIO) |
static <A,B> IO<B> |
Bracket.bracket(IO<A> io,
Fn1<? super A,? extends IO<?>> cleanupIO,
Fn1<? super A,? extends IO<B>> bodyIO) |
static <A,B> IO<B> |
Bracket.bracket(IO<A> io,
Fn1<? super A,? extends IO<?>> cleanupIO,
Fn1<? super A,? extends IO<B>> bodyIO) |
Boolean |
LTBy.checkedApply(Fn1<? super A,? extends B> compareFn,
A y,
A x) |
Boolean |
CmpEqBy.checkedApply(Fn1<? super A,? extends B> compareFn,
A x,
A y) |
Boolean |
GTBy.checkedApply(Fn1<? super A,? extends B> compareFn,
A y,
A x) |
Boolean |
LTEBy.checkedApply(Fn1<? super A,? extends B> compareFn,
A y,
A x) |
Boolean |
GTEBy.checkedApply(Fn1<? super A,? extends B> compareFn,
A y,
A x) |
A |
Times.checkedApply(Integer n,
Fn1<? super A,? extends A> fn,
A a) |
IO<B> |
Bracket.checkedApply(IO<A> io,
Fn1<? super A,? extends IO<?>> cleanupIO,
Fn1<? super A,? extends IO<B>> bodyIO) |
IO<B> |
Bracket.checkedApply(IO<A> io,
Fn1<? super A,? extends IO<?>> cleanupIO,
Fn1<? super A,? extends IO<B>> bodyIO) |
static <A,B extends Comparable<B>> |
CmpEqBy.cmpEqBy(Fn1<? super A,? extends B> compareFn) |
static <A,B extends Comparable<B>> |
CmpEqBy.cmpEqBy(Fn1<? super A,? extends B> compareFn,
A x) |
static <A,B extends Comparable<B>> |
CmpEqBy.cmpEqBy(Fn1<? super A,? extends B> compareFn,
A x,
A y) |
static <A,B extends Comparable<B>> |
GTBy.gtBy(Fn1<? super A,? extends B> fn) |
static <A,B extends Comparable<B>> |
GTBy.gtBy(Fn1<? super A,? extends B> fn,
A y) |
static <A,B extends Comparable<B>> |
GTBy.gtBy(Fn1<? super A,? extends B> fn,
A y,
A x) |
static <A,B extends Comparable<B>> |
GTEBy.gteBy(Fn1<? super A,? extends B> fn) |
static <A,B extends Comparable<B>> |
GTEBy.gteBy(Fn1<? super A,? extends B> fn,
A y) |
static <A,B extends Comparable<B>> |
GTEBy.gteBy(Fn1<? super A,? extends B> fn,
A y,
A x) |
static <A,B extends Comparable<B>> |
LTBy.ltBy(Fn1<? super A,? extends B> fn) |
static <A,B extends Comparable<B>> |
LTBy.ltBy(Fn1<? super A,? extends B> fn,
A y) |
static <A,B extends Comparable<B>> |
LTBy.ltBy(Fn1<? super A,? extends B> fn,
A y,
A x) |
static <A,B extends Comparable<B>> |
LTEBy.lteBy(Fn1<? super A,? extends B> fn) |
static <A,B extends Comparable<B>> |
LTEBy.lteBy(Fn1<? super A,? extends B> fn,
A y) |
static <A,B extends Comparable<B>> |
LTEBy.lteBy(Fn1<? super A,? extends B> fn,
A y,
A x) |
static <A> Fn1<A,A> |
Times.times(Integer n,
Fn1<? super A,? extends A> fn) |
static <A> A |
Times.times(Integer n,
Fn1<? super A,? extends A> fn,
A a) |
| 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> Fn1<A,B> |
IfThenElse.ifThenElse(Fn1<? super A,? extends Boolean> predicate,
Fn1<? super A,? extends B> thenCase,
Fn1<? super A,? extends B> elseCase) |
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> Fn1<Iterable<A>,Iterable<A>> |
RateLimit.rateLimit(Fn0<Instant> instantFn0,
Long limit,
Duration duration) |
| 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> Fn3<Fn1<? super A,? extends B>,Fn1<? super A,? extends B>,A,B> |
IfThenElse.ifThenElse(Fn1<? super A,? extends Boolean> predicate) |
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) |
| Modifier and Type | Method and Description |
|---|---|
B |
IfThenElse.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Fn1<? super A,? extends B> thenCase,
Fn1<? super A,? extends B> elseCase,
A a) |
B |
IfThenElse.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Fn1<? super A,? extends B> thenCase,
Fn1<? super A,? extends B> elseCase,
A a) |
B |
IfThenElse.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Fn1<? super A,? extends B> thenCase,
Fn1<? super A,? extends B> elseCase,
A a) |
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> 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> 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> Fn1<A,B> |
IfThenElse.ifThenElse(Fn1<? super A,? extends Boolean> predicate,
Fn1<? super A,? extends B> thenCase,
Fn1<? super A,? extends B> elseCase) |
static <A,B> Fn1<A,B> |
IfThenElse.ifThenElse(Fn1<? super A,? extends Boolean> predicate,
Fn1<? super A,? extends B> thenCase,
Fn1<? super A,? extends B> elseCase) |
static <A,B> Fn1<A,B> |
IfThenElse.ifThenElse(Fn1<? super A,? extends Boolean> predicate,
Fn1<? super A,? extends B> thenCase,
Fn1<? super A,? extends B> elseCase) |
static <A,B> B |
IfThenElse.ifThenElse(Fn1<? super A,? extends Boolean> predicate,
Fn1<? super A,? extends B> thenCase,
Fn1<? super A,? extends B> elseCase,
A a) |
static <A,B> B |
IfThenElse.ifThenElse(Fn1<? super A,? extends Boolean> predicate,
Fn1<? super A,? extends B> thenCase,
Fn1<? super A,? extends B> elseCase,
A a) |
static <A,B> B |
IfThenElse.ifThenElse(Fn1<? super A,? extends Boolean> predicate,
Fn1<? super A,? extends B> thenCase,
Fn1<? super A,? extends B> elseCase,
A a) |
| 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,
Applicative<B,App> appB,
Applicative<C,App> appC) |
| 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,
Applicative<C,App> appC,
Applicative<D,App> appD) |
| 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,
Applicative<D,App> appD,
Applicative<E,App> appE) |
| 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,
Applicative<E,App> appE,
Applicative<F,App> appF) |
| Modifier and Type | Class and Description |
|---|---|
class |
Trampoline<A,B>
Given an
A) back to the original function,
and then terminating on and returning the first output (B). |
| Modifier and Type | Method and Description |
|---|---|
static <A,B> Fn1<A,B> |
Trampoline.trampoline(Fn1<? super A,? extends RecursiveResult<A,B>> fn) |
| Modifier and Type | Method and Description |
|---|---|
<C,D> RecursiveResult<C,D> |
RecursiveResult.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually map covariantly over both the left and right parameters.
|
<C,D> RecursiveResult<C,D> |
RecursiveResult.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually map covariantly over both the left and right parameters.
|
<C> RecursiveResult<C,B> |
RecursiveResult.biMapL(Fn1<? super A,? extends C> fn)
Covariantly map over the left parameter.
|
<C> RecursiveResult<A,C> |
RecursiveResult.biMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the right parameter.
|
B |
Trampoline.checkedApply(Fn1<? super A,? extends RecursiveResult<A,B>> fn,
A a) |
<C> RecursiveResult<A,C> |
RecursiveResult.flatMap(Fn1<? super B,? extends Monad<C,RecursiveResult<A,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<C> RecursiveResult<A,C> |
RecursiveResult.fmap(Fn1<? super B,? extends C> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
static <A,B> Fn1<A,B> |
Trampoline.trampoline(Fn1<? super A,? extends RecursiveResult<A,B>> fn) |
static <A,B> B |
Trampoline.trampoline(Fn1<? super A,? extends RecursiveResult<A,B>> fn,
A a) |
<C> RecursiveResult<A,C> |
RecursiveResult.trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,RecursiveResult<A,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<C,App extends Applicative<?,App>,TravB extends Traversable<C,RecursiveResult<A,?>>,AppTrav extends Applicative<TravB,App>> |
RecursiveResult.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<C,App extends Applicative<?,App>,TravB extends Traversable<C,RecursiveResult<A,?>>,AppTrav extends Applicative<TravB,App>> |
RecursiveResult.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
| Modifier and Type | Method and Description |
|---|---|
<C> RecursiveResult<A,C> |
RecursiveResult.zip(Applicative<Fn1<? super B,? extends C>,RecursiveResult<A,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
BiMonoidFactory<A,B,C> |
interface |
BiPredicate<A,B>
|
interface |
BiSemigroupFactory<A,B,C> |
interface |
Kleisli<A,B,M extends Monad<?,M>,MB extends Monad<B,M>>
|
interface |
MonoidFactory<A,B> |
interface |
Predicate<A>
A specialized
Fn1 that returns a Boolean. |
interface |
SemigroupFactory<A,B> |
| Modifier and Type | Method and Description |
|---|---|
default <Z> Fn2<Z,B,Boolean> |
BiPredicate.contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B. |
default <Z> Predicate<Z> |
Predicate.contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B. |
default <Z> Kleisli<Z,B,M,MB> |
Kleisli.contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B. |
default <Z> BiPredicate<Z,B> |
BiPredicate.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 <Z> Predicate<Z> |
Predicate.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 <Z> Kleisli<Z,B,M,MB> |
Kleisli.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.
|
static <A,B,M extends Monad<?,M>,MB extends Monad<B,M>> |
Kleisli.kleisli(Fn1<? super A,? extends MB> fn)
Adapt a compatible function into a
Kleisli arrow. |
static <A> Predicate<A> |
Predicate.predicate(Fn1<? super A,? extends Boolean> predicate)
Static factory method to create a predicate from an
Fn1. |
| Modifier and Type | Method and Description |
|---|---|
default <C> Predicate<A> |
Predicate.discardR(Applicative<C,Fn1<A,?>> appB)
Sequence both this
Applicative and appB, discarding appB's result and
returning this Applicative. |
default <C> Kleisli<A,B,M,MB> |
Kleisli.discardR(Applicative<C,Fn1<A,?>> appB)
Sequence both this
Applicative and appB, discarding appB's result and
returning this Applicative. |
default <D> BiPredicate<A,B> |
BiPredicate.discardR(Applicative<D,Fn1<A,?>> appB)
Sequence both this
Applicative and appB, discarding appB's result and
returning this Applicative. |
| Modifier and Type | Method and Description |
|---|---|
<C,D> Bifunctor<C,D,BF> |
Bifunctor.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually map covariantly over both the left and right parameters.
|
<C,D> Bifunctor<C,D,BF> |
Bifunctor.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually map covariantly over both the left and right parameters.
|
<C extends ContraA,D extends ContraB> |
BoundedBifunctor.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually covariantly map both the left and right parameters into values that are covariant to
ContraA
and ContraB, respectively. |
<C extends ContraA,D extends ContraB> |
BoundedBifunctor.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually covariantly map both the left and right parameters into values that are covariant to
ContraA
and ContraB, respectively. |
default <C> Bifunctor<C,B,BF> |
Bifunctor.biMapL(Fn1<? super A,? extends C> fn)
Covariantly map over the left parameter.
|
default <C extends ContraA> |
BoundedBifunctor.biMapL(Fn1<? super A,? extends C> fn)
Covariantly map the left parameter into a value that is covariant to
ContraA. |
default <C> Bifunctor<A,C,BF> |
Bifunctor.biMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the right parameter.
|
default <C extends ContraB> |
BoundedBifunctor.biMapR(Fn1<? super B,? extends C> fn)
Covariantly map the right parameter into a value that is covariant to
ContraB. |
<B> Contravariant<B,C> |
Contravariant.contraMap(Fn1<? super B,? extends A> fn)
Contravariantly map
A <- B. |
default <Z> Cocartesian<Z,B,P> |
Cocartesian.contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B. |
default <Z> Profunctor<Z,B,PF> |
Profunctor.contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B. |
default <Z> Cartesian<Z,B,P> |
Cartesian.contraMap(Fn1<? super Z,? extends A> fn)
Contravariantly map
A <- B. |
<Z,C> Cocartesian<Z,C,P> |
Cocartesian.diMap(Fn1<? super Z,? extends A> lFn,
Fn1<? super B,? extends C> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Z,C> Cocartesian<Z,C,P> |
Cocartesian.diMap(Fn1<? super Z,? extends A> lFn,
Fn1<? super B,? extends C> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Z,C> Profunctor<Z,C,PF> |
Profunctor.diMap(Fn1<? super Z,? extends A> lFn,
Fn1<? super B,? extends C> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Z,C> Profunctor<Z,C,PF> |
Profunctor.diMap(Fn1<? super Z,? extends A> lFn,
Fn1<? super B,? extends C> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Z,C> Cartesian<Z,C,P> |
Cartesian.diMap(Fn1<? super Z,? extends A> lFn,
Fn1<? super B,? extends C> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Z,C> Cartesian<Z,C,P> |
Cartesian.diMap(Fn1<? super Z,? extends A> lFn,
Fn1<? super B,? extends C> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
default <Z> Cocartesian<Z,B,P> |
Cocartesian.diMapL(Fn1<? super Z,? extends A> fn)
Contravariantly map over the left parameter.
|
default <Z> Profunctor<Z,B,PF> |
Profunctor.diMapL(Fn1<? super Z,? extends A> fn)
Contravariantly map over the left parameter.
|
default <Z> Cartesian<Z,B,P> |
Cartesian.diMapL(Fn1<? super Z,? extends A> fn)
Contravariantly map over the left parameter.
|
default <C> Cocartesian<A,C,P> |
Cocartesian.diMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the right parameter.
|
default <C> Profunctor<A,C,PF> |
Profunctor.diMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the right parameter.
|
default <C> Cartesian<A,C,P> |
Cartesian.diMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the right parameter.
|
default <B> Applicative<B,App> |
Applicative.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> Functor<B,F> |
Functor.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
| Modifier and Type | Method and Description |
|---|---|
default <B> Lazy<? extends Applicative<B,App>> |
Applicative.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,App>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Applicative<B,App> |
Applicative.zip(Applicative<Fn1<? super A,? extends B>,App> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Method and Description |
|---|---|
Fn1<? super B,? extends T> |
Market.bt()
Extract the mapping
B -> T. |
Fn1<? super B,? extends T> |
Exchange.bt()
Extract the mapping
B -> T. |
Fn1<? super S,? extends A> |
Exchange.sa()
Extract the mapping
S -> A. |
Fn1<? super S,? extends Either<T,A>> |
Market.sta()
Extract the mapping
S -> . |
| Modifier and Type | Method and Description |
|---|---|
<C,D> Const<C,D> |
Const.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually map covariantly over both the left and right parameters.
|
<C,D> Const<C,D> |
Const.biMap(Fn1<? super A,? extends C> lFn,
Fn1<? super B,? extends D> rFn)
Dually map covariantly over both the left and right parameters.
|
<Z> Const<Z,B> |
Const.biMapL(Fn1<? super A,? extends Z> fn)
Covariantly map over the left parameter.
|
<C> Const<A,C> |
Const.biMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the right parameter.
|
State<S,A> |
State.censor(Fn1<? super S,? extends S> fn)
Update the accumulated state.
|
Writer<W,A> |
Writer.censor(Fn1<? super W,? extends W> fn)
Update the accumulated state.
|
<R> Market<A,B,R,T> |
Market.contraMap(Fn1<? super R,? extends S> fn)
Contravariantly map
A <- B. |
<Z> Tagged<Z,B> |
Tagged.contraMap(Fn1<? super Z,? extends S> fn)
Contravariantly map
A <- B. |
<Z> Exchange<A,B,Z,T> |
Exchange.contraMap(Fn1<? super Z,? extends S> fn)
Contravariantly map
A <- B. |
<R,U> Market<A,B,R,U> |
Market.diMap(Fn1<? super R,? extends S> lFn,
Fn1<? super T,? extends U> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<R,U> Market<A,B,R,U> |
Market.diMap(Fn1<? super R,? extends S> lFn,
Fn1<? super T,? extends U> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Z,C> Tagged<Z,C> |
Tagged.diMap(Fn1<? super Z,? extends S> lFn,
Fn1<? super B,? extends C> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Z,C> Tagged<Z,C> |
Tagged.diMap(Fn1<? super Z,? extends S> lFn,
Fn1<? super B,? extends C> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Z,C> Exchange<A,B,Z,C> |
Exchange.diMap(Fn1<? super Z,? extends S> lFn,
Fn1<? super T,? extends C> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Z,C> Exchange<A,B,Z,C> |
Exchange.diMap(Fn1<? super Z,? extends S> lFn,
Fn1<? super T,? extends C> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<R> Market<A,B,R,T> |
Market.diMapL(Fn1<? super R,? extends S> fn)
Contravariantly map over the left parameter.
|
<Z> Tagged<Z,B> |
Tagged.diMapL(Fn1<? super Z,? extends S> fn)
Contravariantly map over the left parameter.
|
<Z> Exchange<A,B,Z,T> |
Exchange.diMapL(Fn1<? super Z,? extends S> fn)
Contravariantly map over the left parameter.
|
<C> Tagged<S,C> |
Tagged.diMapR(Fn1<? super B,? extends C> fn)
Covariantly map over the right parameter.
|
<C> Exchange<A,B,S,C> |
Exchange.diMapR(Fn1<? super T,? extends C> fn)
Covariantly map over the right parameter.
|
<U> Market<A,B,S,U> |
Market.diMapR(Fn1<? super T,? extends U> fn)
Covariantly map over the right parameter.
|
<B> Identity<B> |
Identity.flatMap(Fn1<? super A,? extends Monad<B,Identity<?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> Lazy<B> |
Lazy.flatMap(Fn1<? super A,? extends Monad<B,Lazy<?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> State<S,B> |
State.flatMap(Fn1<? super A,? extends Monad<B,State<S,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> Writer<W,B> |
Writer.flatMap(Fn1<? super A,? extends Monad<B,Writer<W,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<C> Const<A,C> |
Const.flatMap(Fn1<? super B,? extends Monad<C,Const<A,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<C> Tagged<S,C> |
Tagged.flatMap(Fn1<? super B,? extends Monad<C,Tagged<S,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<U> Market<A,B,S,U> |
Market.flatMap(Fn1<? super T,? extends Monad<U,Market<A,B,S,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> Writer<W,B> |
Writer.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> Compose<F,G,B> |
Compose.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> Identity<B> |
Identity.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> Lazy<B> |
Lazy.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> State<S,B> |
State.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<C> Tagged<S,C> |
Tagged.fmap(Fn1<? super B,? extends C> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<C> Const<A,C> |
Const.fmap(Fn1<? super B,? extends C> fn)
Map over the right parameter.
|
<U> Market<A,B,S,U> |
Market.fmap(Fn1<? super T,? extends U> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
static <S,A> State<S,A> |
State.gets(Fn1<? super S,? extends A> fn)
Create a
State that maps its initial state into its result, but leaves the initial state unchanged. |
<B> State<S,Tuple2<A,B>> |
State.listens(Fn1<? super S,? extends B> fn)
Map the accumulation into a value and pair it with the current output.
|
<B> Writer<W,Tuple2<A,B>> |
Writer.listens(Fn1<? super W,? extends B> fn)
Map the accumulation into a value and pair it with the current output.
|
State<S,A> |
State.local(Fn1<? super S,? extends S> fn)
Modify this
MonadReader's environment after reading it but before running the effect. |
<B> State<S,B> |
State.mapState(Fn1<? super Tuple2<A,S>,? extends Tuple2<B,S>> fn)
Map both the result and the final state to a new result and final state.
|
static <S> State<S,Unit> |
State.modify(Fn1<? super S,? extends S> fn)
|
static <S,A> State<S,A> |
State.state(Fn1<? super S,? extends Tuple2<A,S>> stateFn)
Create a
State from stateFn, a function that maps an initial state into a result and a final
state. |
<B> Identity<B> |
Identity.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Identity<?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> Lazy<B> |
Lazy.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Lazy<?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> State<S,B> |
State.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,State<S,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> Writer<W,B> |
Writer.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Writer<W,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<C> Const<A,C> |
Const.trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Const<A,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<C> Tagged<S,C> |
Tagged.trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Tagged<S,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<U> Market<A,B,S,U> |
Market.trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Market<A,B,S,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,Identity<?>>,AppTrav extends Applicative<TravB,App>> |
Identity.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,Identity<?>>,AppTrav extends Applicative<TravB,App>> |
Identity.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,Lazy<?>>,AppTrav extends Applicative<TravB,App>> |
Lazy.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,Lazy<?>>,AppTrav extends Applicative<TravB,App>> |
Lazy.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<C,App extends Applicative<?,App>,TravB extends Traversable<C,Const<A,?>>,AppTrav extends Applicative<TravB,App>> |
Const.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<C,App extends Applicative<?,App>,TravB extends Traversable<C,Const<A,?>>,AppTrav extends Applicative<TravB,App>> |
Const.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<C,App extends Applicative<?,App>,TravC extends Traversable<C,Tagged<S,?>>,AppTrav extends Applicative<TravC,App>> |
Tagged.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravC,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<C,App extends Applicative<?,App>,TravC extends Traversable<C,Tagged<S,?>>,AppTrav extends Applicative<TravC,App>> |
Tagged.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravC,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
State<S,A> |
State.withState(Fn1<? super S,? extends S> fn)
Map the final state to a new final state using the provided function.
|
| Modifier and Type | Method and Description |
|---|---|
<B> Lazy<Compose<F,G,B>> |
Compose.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Compose<F,G,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Lazy<Identity<B>> |
Identity.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Identity<?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Lazy<State<S,B>> |
State.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,State<S,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Lazy<Writer<W,B>> |
Writer.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Writer<W,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<C> Lazy<Const<A,C>> |
Const.lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Const<A,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Compose<F,G,B> |
Compose.zip(Applicative<Fn1<? super A,? extends B>,Compose<F,G,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> Identity<B> |
Identity.zip(Applicative<Fn1<? super A,? extends B>,Identity<?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> Lazy<B> |
Lazy.zip(Applicative<Fn1<? super A,? extends B>,Lazy<?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> State<S,B> |
State.zip(Applicative<Fn1<? super A,? extends B>,State<S,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> Writer<W,B> |
Writer.zip(Applicative<Fn1<? super A,? extends B>,Writer<W,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<C> Const<A,C> |
Const.zip(Applicative<Fn1<? super B,? extends C>,Const<A,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<C> Tagged<S,C> |
Tagged.zip(Applicative<Fn1<? super B,? extends C>,Tagged<S,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<U> Market<A,B,S,U> |
Market.zip(Applicative<Fn1<? super T,? extends U>,Market<A,B,S,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Constructor and Description |
|---|
Exchange(Fn1<? super S,? extends A> sa,
Fn1<? super B,? extends T> bt) |
Exchange(Fn1<? super S,? extends A> sa,
Fn1<? super B,? extends T> bt) |
Market(Fn1<? super B,? extends T> bt,
Fn1<? super S,? extends Either<T,A>> sta) |
Market(Fn1<? super B,? extends T> bt,
Fn1<? super S,? extends Either<T,A>> sta) |
| Constructor and Description |
|---|
FilteringIterable(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
FilteringIterator(Fn1<? super A,? extends Boolean> predicate,
Iterator<A> iterator) |
MappingIterable(Fn1<? super A,? extends B> fn,
Iterable<A> as) |
MappingIterator(Fn1<? super A,? extends B> function,
Iterator<A> iterator) |
PredicatedDroppingIterable(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
PredicatedDroppingIterator(Fn1<? super A,? extends Boolean> predicate,
Iterator<A> asIterator) |
PredicatedTakingIterable(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
PredicatedTakingIterator(Fn1<? super A,? extends Boolean> predicate,
Iterator<A> asIterator) |
TrampoliningIterator(Fn1<? super A,? extends Iterable<RecursiveResult<A,B>>> fn,
A a) |
UnfoldingIterator(Fn1<? super B,Maybe<Tuple2<A,B>>> function,
B seed) |
| Modifier and Type | Method and Description |
|---|---|
IO<A> |
IO.catchError(Fn1<? super Throwable,? extends Monad<A,IO<?>>> recoveryFn)
|
IO<A> |
IO.exceptionally(Fn1<? super Throwable,? extends A> recoveryFn)
Deprecated.
in favor of canonical
IO.catchError(Fn1) |
<B> IO<B> |
IO.flatMap(Fn1<? super A,? extends Monad<B,IO<?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> IO<B> |
IO.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> IO<B> |
IO.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,IO<?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
| Modifier and Type | Method and Description |
|---|---|
<B> Lazy<IO<B>> |
IO.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,IO<?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> IO<B> |
IO.zip(Applicative<Fn1<? super A,? extends B>,IO<?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Method and Description |
|---|---|
MonadError<E,A,M> |
MonadError.catchError(Fn1<? super E,? extends Monad<A,M>> recoveryFn)
|
MonadWriter<W,A,MW> |
MonadWriter.censor(Fn1<? super W,? extends W> fn)
Update the accumulated state.
|
<B> MonadError<E,B,M> |
MonadError.flatMap(Fn1<? super A,? extends Monad<B,M>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> Monad<B,M> |
Monad.flatMap(Fn1<? super A,? extends Monad<B,M>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> MonadRec<B,M> |
MonadRec.flatMap(Fn1<? super A,? extends Monad<B,M>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> MonadReader<R,B,MR> |
MonadReader.flatMap(Fn1<? super A,? extends Monad<B,MR>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> MonadWriter<W,B,MW> |
MonadWriter.flatMap(Fn1<? super A,? extends Monad<B,MW>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> SafeT<M,B> |
SafeT.flatMap(Fn1<? super A,? extends Monad<B,SafeT<M,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
default <B> MonadError<E,B,M> |
MonadError.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
default <B> MonadWriter<W,B,MW> |
MonadWriter.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> SafeT<M,B> |
SafeT.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
default <B> Monad<B,M> |
Monad.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
default <B> MonadReader<R,B,MR> |
MonadReader.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
default <B> MonadRec<B,M> |
MonadRec.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> MonadWriter<W,Tuple2<A,B>,MW> |
MonadWriter.listens(Fn1<? super W,? extends B> fn)
Map the accumulation into a value and pair it with the current output.
|
MonadReader<R,A,MR> |
MonadReader.local(Fn1<? super R,? extends R> fn)
Modify this
MonadReader's environment after reading it but before running the effect. |
<B> MonadRec<B,M> |
MonadRec.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,M>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> SafeT<M,B> |
SafeT.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,SafeT<M,?>>> bounce)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
| Modifier and Type | Method and Description |
|---|---|
default <B> Lazy<? extends MonadError<E,B,M>> |
MonadError.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
default <B> Lazy<? extends Monad<B,M>> |
Monad.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
default <B> Lazy<? extends MonadRec<B,M>> |
MonadRec.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
default <B> Lazy<? extends MonadReader<R,B,MR>> |
MonadReader.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MR>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
default <B> Lazy<? extends MonadWriter<W,B,MW>> |
MonadWriter.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MW>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Lazy<SafeT<M,B>> |
SafeT.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,SafeT<M,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
default <B> MonadError<E,B,M> |
MonadError.zip(Applicative<Fn1<? super A,? extends B>,M> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
default <B> Monad<B,M> |
Monad.zip(Applicative<Fn1<? super A,? extends B>,M> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
default <B> MonadRec<B,M> |
MonadRec.zip(Applicative<Fn1<? super A,? extends B>,M> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
default <B> MonadReader<R,B,MR> |
MonadReader.zip(Applicative<Fn1<? super A,? extends B>,MR> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
default <B> MonadWriter<W,B,MW> |
MonadWriter.zip(Applicative<Fn1<? super A,? extends B>,MW> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> SafeT<M,B> |
SafeT.zip(Applicative<Fn1<? super A,? extends B>,SafeT<M,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Method and Description |
|---|---|
<B> MonadT<M,B,MT,T> |
MonadT.flatMap(Fn1<? super A,? extends Monad<B,MT>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
default <B> MonadT<M,B,MT,T> |
MonadT.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
| Modifier and Type | Method and Description |
|---|---|
default <B> Lazy<? extends MonadT<M,B,MT,T>> |
MonadT.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MT>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
default <B> MonadT<M,B,MT,T> |
MonadT.zip(Applicative<Fn1<? super A,? extends B>,MT> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Method and Description |
|---|---|
<L2,R2> EitherT<M,L2,R2> |
EitherT.biMap(Fn1<? super L,? extends L2> lFn,
Fn1<? super R,? extends R2> rFn)
Dually map covariantly over both the left and right parameters.
|
<L2,R2> EitherT<M,L2,R2> |
EitherT.biMap(Fn1<? super L,? extends L2> lFn,
Fn1<? super R,? extends R2> rFn)
Dually map covariantly over both the left and right parameters.
|
<L2> EitherT<M,L2,R> |
EitherT.biMapL(Fn1<? super L,? extends L2> fn)
Covariantly map over the left parameter.
|
<R2> EitherT<M,L,R2> |
EitherT.biMapR(Fn1<? super R,? extends R2> fn)
Covariantly map over the right parameter.
|
StateT<S,M,A> |
StateT.censor(Fn1<? super S,? extends S> fn)
Update the accumulated state.
|
WriterT<W,M,A> |
WriterT.censor(Fn1<? super W,? extends W> fn)
Update the accumulated state.
|
<Q> ReaderT<Q,M,A> |
ReaderT.contraMap(Fn1<? super Q,? extends R> fn)
Contravariantly map
A <- B. |
<Q,B> ReaderT<Q,M,B> |
ReaderT.diMap(Fn1<? super Q,? extends R> lFn,
Fn1<? super A,? extends B> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Q,B> ReaderT<Q,M,B> |
ReaderT.diMap(Fn1<? super Q,? extends R> lFn,
Fn1<? super A,? extends B> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Q> ReaderT<Q,M,A> |
ReaderT.diMapL(Fn1<? super Q,? extends R> fn)
Contravariantly map over the left parameter.
|
<B> ReaderT<R,M,B> |
ReaderT.diMapR(Fn1<? super A,? extends B> fn)
Covariantly map over the right parameter.
|
<B> IdentityT<M,B> |
IdentityT.flatMap(Fn1<? super A,? extends Monad<B,IdentityT<M,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> LazyT<M,B> |
LazyT.flatMap(Fn1<? super A,? extends Monad<B,LazyT<M,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> MaybeT<M,B> |
MaybeT.flatMap(Fn1<? super A,? extends Monad<B,MaybeT<M,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> ReaderT<R,M,B> |
ReaderT.flatMap(Fn1<? super A,? extends Monad<B,ReaderT<R,M,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> StateT<S,M,B> |
StateT.flatMap(Fn1<? super A,? extends Monad<B,StateT<S,M,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> WriterT<W,M,B> |
WriterT.flatMap(Fn1<? super A,? extends Monad<B,WriterT<W,M,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<R2> EitherT<M,L,R2> |
EitherT.flatMap(Fn1<? super R,? extends Monad<R2,EitherT<M,L,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> LazyT<M,B> |
LazyT.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> MaybeT<M,B> |
MaybeT.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> WriterT<W,M,B> |
WriterT.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> StateT<S,M,B> |
StateT.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> ReaderT<R,M,B> |
ReaderT.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> IdentityT<M,B> |
IdentityT.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<R2> EitherT<M,L,R2> |
EitherT.fmap(Fn1<? super R,? extends R2> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
static <S,M extends MonadRec<?,M>,A> |
StateT.gets(Fn1<? super S,? extends MonadRec<A,M>> fn)
Given a function that produces a value inside a
monadic effect from a state, produce a
StateT that simply passes its state to the function and applies it. |
<B> StateT<S,M,Tuple2<A,B>> |
StateT.listens(Fn1<? super S,? extends B> fn)
Map the accumulation into a value and pair it with the current output.
|
<B> WriterT<W,M,Tuple2<A,B>> |
WriterT.listens(Fn1<? super W,? extends B> fn)
Map the accumulation into a value and pair it with the current output.
|
ReaderT<R,M,A> |
ReaderT.local(Fn1<? super R,? extends R> fn)
Modify this
MonadReader's environment after reading it but before running the effect. |
StateT<S,M,A> |
StateT.local(Fn1<? super S,? extends S> fn)
Modify this
MonadReader's environment after reading it but before running the effect. |
<MA extends MonadRec<A,M>,N extends MonadRec<?,N>,B> |
ReaderT.mapReaderT(Fn1<? super MA,? extends MonadRec<B,N>> fn)
|
<N extends MonadRec<?,N>,B> |
StateT.mapStateT(Fn1<? super MonadRec<Tuple2<A,S>,M>,? extends MonadRec<Tuple2<B,S>,N>> fn)
Map both the result and the final state to a new result and final state inside the
Monad. |
static <S,M extends MonadRec<?,M>> |
StateT.modify(Fn1<? super S,? extends MonadRec<S,M>> updateFn)
|
static <R,M extends MonadRec<?,M>,A> |
ReaderT.readerT(Fn1<? super R,? extends MonadRec<A,M>> fn)
|
static <S,M extends MonadRec<?,M>,A> |
StateT.stateT(Fn1<? super S,? extends MonadRec<Tuple2<A,S>,M>> stateFn)
Lift a state-sensitive
monadically embedded computation into StateT. |
<B> IdentityT<M,B> |
IdentityT.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,IdentityT<M,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> LazyT<M,B> |
LazyT.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,LazyT<M,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> MaybeT<M,B> |
MaybeT.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,MaybeT<M,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> ReaderT<R,M,B> |
ReaderT.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,ReaderT<R,M,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> StateT<S,M,B> |
StateT.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,StateT<S,M,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> WriterT<W,M,B> |
WriterT.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,WriterT<W,M,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<R2> EitherT<M,L,R2> |
EitherT.trampolineM(Fn1<? super R,? extends MonadRec<RecursiveResult<R,R2>,EitherT<M,L,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
StateT<S,M,A> |
StateT.withStateT(Fn1<? super S,? extends MonadRec<S,M>> fn)
Map the final state to a new final state inside the same
monadic effect using the provided
function. |
| Modifier and Type | Method and Description |
|---|---|
<B> Lazy<IdentityT<M,B>> |
IdentityT.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,IdentityT<M,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Lazy<LazyT<M,B>> |
LazyT.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,LazyT<M,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Lazy<MaybeT<M,B>> |
MaybeT.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MaybeT<M,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Lazy<ReaderT<R,M,B>> |
ReaderT.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,ReaderT<R,M,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Lazy<StateT<S,M,B>> |
StateT.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,StateT<S,M,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> Lazy<WriterT<W,M,B>> |
WriterT.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,WriterT<W,M,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<R2> Lazy<EitherT<M,L,R2>> |
EitherT.lazyZip(Lazy<? extends Applicative<Fn1<? super R,? extends R2>,EitherT<M,L,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> IdentityT<M,B> |
IdentityT.zip(Applicative<Fn1<? super A,? extends B>,IdentityT<M,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> LazyT<M,B> |
LazyT.zip(Applicative<Fn1<? super A,? extends B>,LazyT<M,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> MaybeT<M,B> |
MaybeT.zip(Applicative<Fn1<? super A,? extends B>,MaybeT<M,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> ReaderT<R,M,B> |
ReaderT.zip(Applicative<Fn1<? super A,? extends B>,ReaderT<R,M,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> StateT<S,M,B> |
StateT.zip(Applicative<Fn1<? super A,? extends B>,StateT<S,M,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<B> WriterT<W,M,B> |
WriterT.zip(Applicative<Fn1<? super A,? extends B>,WriterT<W,M,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
<R2> EitherT<M,L,R2> |
EitherT.zip(Applicative<Fn1<? super R,? extends R2>,EitherT<M,L,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
Monoid<A>
|
| Modifier and Type | Method and Description |
|---|---|
default <B> A |
Monoid.foldMap(Fn1<? super B,? extends A> fn,
Iterable<B> bs)
Homomorphism combined with catamorphism.
|
| 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 |
And
A
Monoid instance formed by Boolean. |
class |
Collapse<_1,_2>
|
class |
Compose<A>
|
class |
Concat<A>
|
class |
Endo<A>
|
class |
EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>
The monoid formed under monadic endomorphism.
|
class |
First<A>
|
class |
Join
A
Monoid instance formed by String that concats two strings together. |
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 |
Or
A
Monoid instance formed by Boolean. |
class |
Present<A>
|
class |
PutAll
|
class |
RightAll<L,R>
|
class |
RightAny<L,R>
|
class |
RunAll<A>
|
class |
Trivial
|
class |
Union<A>
|
class |
Xor
Logical exclusive-or.
|
| Modifier and Type | Method and Description |
|---|---|
static <A,C extends Collection<A>> |
AddAll.addAll(Fn0<C> collectionFn0,
C xs) |
static Fn1<Boolean,Boolean> |
And.and(Boolean x) |
Fn1<A,A> |
Endo.checkedApply(Fn1<A,A> f,
Fn1<A,A> g) |
static <_1,_2> Fn1<Tuple2<_1,_2>,Tuple2<_1,_2>> |
Collapse.collapse(Monoid<_1> _1Monoid,
Monoid<_2> _2Monoid,
Tuple2<_1,_2> x) |
static <A> Fn1<CompletableFuture<A>,CompletableFuture<A>> |
Compose.compose(Monoid<A> aMonoid,
CompletableFuture<A> x) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Concat.concat(Iterable<A> xs) |
static <A> Fn1<A,A> |
Endo.endo(Fn1<A,A> f,
Fn1<A,A> g) |
static <A> Fn1<Maybe<A>,Maybe<A>> |
First.first(Maybe<A> x) |
Fn1<A,A> |
Endo.identity() |
static Fn1<String,String> |
Join.join(String x) |
static <A> Fn1<Maybe<A>,Maybe<A>> |
Last.last(Maybe<A> x) |
static <L,R> Fn1<Either<L,R>,Either<L,R>> |
LeftAll.leftAll(Monoid<L> lMonoid,
Either<L,R> x) |
static <L,R> Fn1<Either<L,R>,Either<L,R>> |
LeftAny.leftAny(Monoid<L> lMonoid,
Either<L,R> x) |
static <L,R> Fn1<Either<L,R>,Either<L,R>> |
Merge.merge(Semigroup<L> lSemigroup,
Monoid<R> rMonoid,
Either<L,R> x) |
static <K,V> Fn1<Map<K,V>,Map<K,V>> |
MergeMaps.mergeMaps(Fn0<Map<K,V>> mFn0,
Semigroup<V> semigroup,
Map<K,V> x) |
static Fn1<Boolean,Boolean> |
Or.or(Boolean x) |
static <A> Fn1<Maybe<A>,Maybe<A>> |
Present.present(Semigroup<A> aSemigroup,
Maybe<A> x) |
static Fn1<HMap,HMap> |
PutAll.putAll(HMap x) |
static <L,R> Fn1<Either<L,R>,Either<L,R>> |
RightAll.rightAll(Monoid<R> rMonoid,
Either<L,R> x) |
static <L,R> Fn1<Either<L,R>,Either<L,R>> |
RightAny.rightAny(Monoid<R> rMonoid,
Either<L,R> x) |
static <A> Fn1<IO<A>,IO<A>> |
RunAll.runAll(Monoid<A> monoid,
IO<A> x) |
static Fn1<Unit,Unit> |
Trivial.trivial(Unit x) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Union.union(Iterable<A> xs) |
static Fn1<Boolean,Boolean> |
Xor.xor(Boolean x) |
| Modifier and Type | Method and Description |
|---|---|
Fn2<Fn1<A,A>,A,A> |
Endo.apply(Fn1<A,A> f) |
Monoid<Fn1<A,MA>> |
EndoK.checkedApply(Pure<M> pureM) |
static <A> Fn2<Fn1<A,A>,A,A> |
Endo.endo(Fn1<A,A> f) |
static <M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>> |
EndoK.endoK(Pure<M> pureM) |
| Modifier and Type | Method and Description |
|---|---|
Fn2<Fn1<A,A>,A,A> |
Endo.apply(Fn1<A,A> f) |
A |
Endo.apply(Fn1<A,A> f,
Fn1<A,A> g,
A a) |
A |
Endo.apply(Fn1<A,A> f,
Fn1<A,A> g,
A a) |
Fn1<A,A> |
Endo.checkedApply(Fn1<A,A> f,
Fn1<A,A> g) |
Fn1<A,A> |
Endo.checkedApply(Fn1<A,A> f,
Fn1<A,A> g) |
static <A> Fn2<Fn1<A,A>,A,A> |
Endo.endo(Fn1<A,A> f) |
static <A> Fn1<A,A> |
Endo.endo(Fn1<A,A> f,
Fn1<A,A> g) |
static <A> Fn1<A,A> |
Endo.endo(Fn1<A,A> f,
Fn1<A,A> g) |
static <A> A |
Endo.endo(Fn1<A,A> f,
Fn1<A,A> g,
A a) |
static <A> A |
Endo.endo(Fn1<A,A> f,
Fn1<A,A> g,
A a) |
<B> Boolean |
And.foldMap(Fn1<? super B,? extends Boolean> fn,
Iterable<B> bs) |
<B> Boolean |
Or.foldMap(Fn1<? super B,? extends Boolean> fn,
Iterable<B> bs) |
<B> Iterable<A> |
Concat.foldMap(Fn1<? super B,? extends Iterable<A>> fn,
Iterable<B> bs) |
<B> Maybe<A> |
First.foldMap(Fn1<? super B,? extends Maybe<A>> fn,
Iterable<B> bs) |
| Modifier and Type | Method and Description |
|---|---|
default <CoP extends Profunctor<?,?,? extends P>,CoF extends Functor<?,? extends F>,FB extends Functor<B,? extends CoF>,FT extends Functor<T,? extends CoF>,PAFB extends Profunctor<A,FB,? extends CoP>,PSFT extends Profunctor<S,FT,? extends CoP>> |
Optic.monomorphize()
|
| Modifier and Type | Method and Description |
|---|---|
default Tuple2<Fn1<? super S,? extends A>,Fn1<? super B,? extends T>> |
Iso.unIso()
|
default Tuple2<Fn1<? super S,? extends A>,Fn1<? super B,? extends T>> |
Iso.unIso()
|
default Tuple2<Fn1<? super B,? extends T>,Fn1<? super S,? extends Either<T,A>>> |
Prism.unPrism()
|
default Tuple2<Fn1<? super B,? extends T>,Fn1<? super S,? extends Either<T,A>>> |
Prism.unPrism()
|
| Modifier and Type | Method and Description |
|---|---|
default <R> Prism<R,T,A,B> |
Prism.contraMap(Fn1<? super R,? extends S> fn)
Contravariantly map
A <- B. |
default <R> Lens<R,T,A,B> |
Lens.contraMap(Fn1<? super R,? extends S> fn)
Contravariantly map
A <- B. |
default <R> Iso<R,T,A,B> |
Iso.contraMap(Fn1<? super R,? extends S> fn)
Contravariantly map
A <- B. |
default <R,U> Prism<R,U,A,B> |
Prism.diMap(Fn1<? super R,? extends S> lFn,
Fn1<? super T,? extends U> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
default <R,U> Prism<R,U,A,B> |
Prism.diMap(Fn1<? super R,? extends S> lFn,
Fn1<? super T,? extends U> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
default <R,U> Lens<R,U,A,B> |
Lens.diMap(Fn1<? super R,? extends S> lFn,
Fn1<? super T,? extends U> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
default <R,U> Lens<R,U,A,B> |
Lens.diMap(Fn1<? super R,? extends S> lFn,
Fn1<? super T,? extends U> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
default <R,U> Iso<R,U,A,B> |
Iso.diMap(Fn1<? super R,? extends S> lFn,
Fn1<? super T,? extends U> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
default <R,U> Iso<R,U,A,B> |
Iso.diMap(Fn1<? super R,? extends S> lFn,
Fn1<? super T,? extends U> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
default <R> Prism<R,T,A,B> |
Prism.diMapL(Fn1<? super R,? extends S> fn)
Contravariantly map over the left parameter.
|
default <R> Lens<R,T,A,B> |
Lens.diMapL(Fn1<? super R,? extends S> fn)
Contravariantly map over the left parameter.
|
default <R> Iso<R,T,A,B> |
Iso.diMapL(Fn1<? super R,? extends S> fn)
Contravariantly map over the left parameter.
|
default <U> Prism<S,U,A,B> |
Prism.diMapR(Fn1<? super T,? extends U> fn)
Covariantly map over the right parameter.
|
default <U> Lens<S,U,A,B> |
Lens.diMapR(Fn1<? super T,? extends U> fn)
Covariantly map over the right parameter.
|
default <U> Iso<S,U,A,B> |
Iso.diMapR(Fn1<? super T,? extends U> fn)
Covariantly map over the right parameter.
|
default <U> Iso<S,U,A,B> |
Iso.flatMap(Fn1<? super T,? extends Monad<U,Iso<S,?,A,B>>> fn)
Chain dependent computations that may continue or short-circuit based on previous results.
|
default <U> Lens<S,U,A,B> |
Lens.flatMap(Fn1<? super T,? extends Monad<U,Lens<S,?,A,B>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
default <U> Prism<S,U,A,B> |
Prism.flatMap(Fn1<? super T,? extends Monad<U,Prism<S,?,A,B>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
default <U> Prism<S,U,A,B> |
Prism.fmap(Fn1<? super T,? extends U> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
default <U> Lens<S,U,A,B> |
Lens.fmap(Fn1<? super T,? extends U> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
default <U> Iso<S,U,A,B> |
Iso.fmap(Fn1<? super T,? extends U> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
static <S,A> Prism.Simple<S,A> |
Prism.Simple.fromPartial(Fn1<? super S,? extends A> partialSa,
Fn1<? super A,? extends S> as)
Static factory method for creating a
simple Prism from a partial function
S -> A and a total function A -> T. |
static <S,A> Prism.Simple<S,A> |
Prism.Simple.fromPartial(Fn1<? super S,? extends A> partialSa,
Fn1<? super A,? extends S> as)
Static factory method for creating a
simple Prism from a partial function
S -> A and a total function A -> T. |
static <S,A,B> Prism<S,S,A,B> |
Prism.fromPartial(Fn1<? super S,? extends A> partialSa,
Fn1<? super B,? extends S> bs)
Static factory method for creating a
Prism from a partial function S -> A and a total
function B -> S. |
static <S,A,B> Prism<S,S,A,B> |
Prism.fromPartial(Fn1<? super S,? extends A> partialSa,
Fn1<? super B,? extends S> bs)
Static factory method for creating a
Prism from a partial function S -> A and a total
function B -> S. |
static <S,T,A,B> Iso<S,T,A,B> |
Iso.iso(Fn1<? super S,? extends A> f,
Fn1<? super B,? extends T> g)
Static factory method for creating an iso from a function and it's inverse.
|
static <S,T,A,B> Iso<S,T,A,B> |
Iso.iso(Fn1<? super S,? extends A> f,
Fn1<? super B,? extends T> g)
Static factory method for creating an iso from a function and it's inverse.
|
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.
|
default <C> Prism<S,T,C,B> |
Prism.mapA(Fn1<? super A,? extends C> fn)
Covariantly map
A to C, yielding a new optic. |
default <C> Optic<P,F,S,T,C,B> |
Optic.mapA(Fn1<? super A,? extends C> fn)
Covariantly map
A to C, yielding a new optic. |
default <C> Lens<S,T,C,B> |
Lens.mapA(Fn1<? super A,? extends C> fn)
Covariantly map
A to C, yielding a new optic. |
default <C> ProtoOptic<P,S,T,C,B> |
ProtoOptic.mapA(Fn1<? super A,? extends C> fn)
Covariantly map
A to C, yielding a new optic. |
default <C> Iso<S,T,C,B> |
Iso.mapA(Fn1<? super A,? extends C> fn)
Covariantly map
A to C, yielding a new optic. |
default <Z> Prism<S,T,A,Z> |
Prism.mapB(Fn1<? super Z,? extends B> fn)
Contravariantly map
B to Z, yielding a new optic. |
default <Z> Optic<P,F,S,T,A,Z> |
Optic.mapB(Fn1<? super Z,? extends B> fn)
Contravariantly map
B to Z, yielding a new optic. |
default <Z> Lens<S,T,A,Z> |
Lens.mapB(Fn1<? super Z,? extends B> fn)
Contravariantly map
B to Z, yielding a new optic. |
default <Z> ProtoOptic<P,S,T,A,Z> |
ProtoOptic.mapB(Fn1<? super Z,? extends B> fn)
Contravariantly map
B to Z, yielding a new optic. |
default <Z> Iso<S,T,A,Z> |
Iso.mapB(Fn1<? super Z,? extends B> fn)
Contravariantly map
B to Z, yielding a new optic. |
default <R> Prism<R,T,A,B> |
Prism.mapS(Fn1<? super R,? extends S> fn)
Contravariantly map
S to R, yielding a new optic. |
default <R> Optic<P,F,R,T,A,B> |
Optic.mapS(Fn1<? super R,? extends S> fn)
Contravariantly map
S to R, yielding a new optic. |
default <R> Lens<R,T,A,B> |
Lens.mapS(Fn1<? super R,? extends S> fn)
Contravariantly map
S to R, yielding a new optic. |
default <R> ProtoOptic<P,R,T,A,B> |
ProtoOptic.mapS(Fn1<? super R,? extends S> fn)
Contravariantly map
S to R, yielding a new optic. |
default <R> Iso<R,T,A,B> |
Iso.mapS(Fn1<? super R,? extends S> fn)
Contravariantly map
S to R, yielding a new optic. |
default <U> Prism<S,U,A,B> |
Prism.mapT(Fn1<? super T,? extends U> fn)
Covariantly map
T to U, yielding a new optic. |
default <U> Optic<P,F,S,U,A,B> |
Optic.mapT(Fn1<? super T,? extends U> fn)
Covariantly map
T to U, yielding a new optic. |
default <U> Lens<S,U,A,B> |
Lens.mapT(Fn1<? super T,? extends U> fn)
Covariantly map
T to U, yielding a new optic. |
default <U> ProtoOptic<P,S,U,A,B> |
ProtoOptic.mapT(Fn1<? super T,? extends U> fn)
Covariantly map
T to U, yielding a new optic. |
default <U> Iso<S,U,A,B> |
Iso.mapT(Fn1<? super T,? extends U> fn)
Covariantly map
T to U, yielding a new optic. |
static <P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,T,A,B,FB extends Functor<B,? extends F>,FT extends Functor<T,? extends F>,PAFB extends Profunctor<A,FB,? extends P>,PSFT extends Profunctor<S,FT,? extends P>> |
Optic.optic(Fn1<PAFB,PSFT> fn)
Promote a monomorphic function to a compatible
Optic. |
static <S,T,A,B> Prism<S,T,A,B> |
Prism.prism(Fn1<? super S,? extends CoProduct2<T,A,?>> sta,
Fn1<? super B,? extends T> bt)
|
static <S,T,A,B> Prism<S,T,A,B> |
Prism.prism(Fn1<? super S,? extends CoProduct2<T,A,?>> sta,
Fn1<? super B,? extends T> bt)
|
static <S,A,B> Pure<Iso<S,?,A,B>> |
Iso.pureIso(Fn1<? super S,? extends A> sa)
|
static <S,A,B> Pure<Lens<S,?,A,B>> |
Lens.pureLens(Fn1<? super S,? extends A> sa)
|
static <S,A> Iso.Simple<S,A> |
Iso.simpleIso(Fn1<? super S,? extends A> f,
Fn1<? super A,? extends S> g)
Static factory method for creating a simple
Iso from a function and its inverse. |
static <S,A> Iso.Simple<S,A> |
Iso.simpleIso(Fn1<? super S,? extends A> f,
Fn1<? super A,? extends S> g)
Static factory method for creating a simple
Iso from a function and its inverse. |
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.
|
static <S,A> Prism.Simple<S,A> |
Prism.simplePrism(Fn1<? super S,? extends Maybe<A>> sMaybeA,
Fn1<? super A,? extends S> as)
Static factory method for creating a simple
Prism from a function and its potentially failing inverse. |
static <S,A> Prism.Simple<S,A> |
Prism.simplePrism(Fn1<? super S,? extends Maybe<A>> sMaybeA,
Fn1<? super A,? extends S> as)
Static factory method for creating a simple
Prism from a function and its potentially failing inverse. |
default <U> Iso<S,U,A,B> |
Iso.trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Iso<S,?,A,B>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
default <U> Lens<S,U,A,B> |
Lens.trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Lens<S,?,A,B>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
default <U> Prism<S,U,A,B> |
Prism.trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Prism<S,?,A,B>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
| Modifier and Type | Method and Description |
|---|---|
default <U> Lazy<Prism<S,U,A,B>> |
Prism.lazyZip(Lazy<? extends Applicative<Fn1<? super T,? extends U>,Prism<S,?,A,B>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
default <U> Iso<S,U,A,B> |
Iso.zip(Applicative<Fn1<? super T,? extends U>,Iso<S,?,A,B>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
default <U> Lens<S,U,A,B> |
Lens.zip(Applicative<Fn1<? super T,? extends U>,Lens<S,?,A,B>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
default <U> Prism<S,U,A,B> |
Prism.zip(Applicative<Fn1<? super T,? extends U>,Prism<S,?,A,B>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Matching<S,T,A,B> |
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 |
Pre<P extends Profunctor<?,?,? extends P>,S,T,A,B>
|
class |
Re<S,T,A,B>
Turn an
Optic with a unary mapping that can be used for setting (e.g. |
class |
Set<S,T,A,B>
|
class |
Under<S,T,A,B>
|
class |
View<S,T,A,B>
|
| Modifier and Type | Method and Description |
|---|---|
static <S,T,A,B> Fn1<S,Either<T,A>> |
Matching.matching(Optic<? super Market<A,B,?,?>,? super Identity<?>,S,T,A,B> optic) |
static <S,T,A,B> Fn1<S,T> |
Over.over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super A,? extends B> fn) |
static <S,T,A,B> Fn1<S,T> |
Set.set(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
B b) |
static <S,T,A,B> Fn1<B,A> |
Under.under(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super T,? extends S> fn) |
static <S,T,A,B> Fn1<S,A> |
View.view(Optic<? super Fn1<?,?>,? super Const<A,?>,S,T,A,B> optic) |
| Modifier and Type | Method and 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<Fn1<? super T,? extends S>,B,A> |
Under.under(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic) |
| Modifier and Type | Method and Description |
|---|---|
A |
Under.checkedApply(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super T,? extends S> fn,
B b) |
T |
Over.checkedApply(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super A,? extends B> fn,
S s) |
static <S,T,A,B> Fn1<S,T> |
Over.over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super A,? extends B> fn) |
static <S,T,A,B> T |
Over.over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super A,? extends B> fn,
S s) |
static <S,T,A,B> Fn1<B,A> |
Under.under(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super T,? extends S> fn) |
static <S,T,A,B> A |
Under.under(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super T,? extends S> fn,
B b) |
| Modifier and Type | Method and Description |
|---|---|
A |
View.checkedApply(Optic<? super Fn1<?,?>,? super Const<A,?>,S,T,A,B> optic,
S s) |
T |
Set.checkedApply(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
B b,
S s) |
T |
Over.checkedApply(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super A,? extends B> fn,
S s) |
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> Fn1<S,T> |
Over.over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super A,? extends B> fn) |
static <S,T,A,B> T |
Over.over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
Fn1<? super A,? extends B> fn,
S s) |
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> Fn1<S,T> |
Set.set(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
B b) |
static <S,T,A,B> T |
Set.set(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic,
B b,
S s) |
static <S,T,A,B> Fn1<S,A> |
View.view(Optic<? super Fn1<?,?>,? super Const<A,?>,S,T,A,B> optic) |
static <S,T,A,B> A |
View.view(Optic<? super Fn1<?,?>,? super Const<A,?>,S,T,A,B> optic,
S s) |
| Modifier and Type | Method and Description |
|---|---|
static <X,CX extends Collection<X>> |
CollectionLens.asCopy(Fn1<? super CX,? extends CX> copyFn)
Convenience static factory method for creating a lens that focuses on a copy of a
Collection, given
a function that creates the copy. |
static <M extends Map<K,V>,K,V> |
MapLens.asCopy(Fn1<? super Map<K,V>,? extends M> copyFn)
A lens that focuses on a copy of a
Map as a subtype M. |
static <X,CX extends Collection<X>> |
CollectionLens.asSet(Fn1<? super CX,? extends CX> copyFn)
Convenience static factory method for creating a lens that focuses on an arbitrary
Collection as a
Set. |
static <X,CX extends Collection<X>> |
CollectionLens.asStream(Fn1<? super CX,? extends CX> copyFn)
Convenience static factory method for creating a lens that focuses on a Collection as a Stream.
|
static <A,SetA extends Set<A>> |
SetLens.contains(Fn1<? super SetA,? extends SetA> copyFn,
A a)
A lens that focuses on whether a
Set contains some value a. |
static <M extends Map<K,V>,K,V> |
MapLens.valueAt(Fn1<? super Map<K,V>,? extends M> copyFn,
K k)
A lens that focuses on a value at a key in a map, as a
Maybe, and produces a subtype M on
the way back out. |
| Modifier and Type | Method and Description |
|---|---|
static <M extends Map<K,V>,K,V> |
MapPrism.valueAt(Fn1<Map<K,V>,M> copyFn,
K k)
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
Semigroup<A>
A
Semigroup is a closed, associative category. |
| Modifier and Type | Class and Description |
|---|---|
class |
Absent<A>
|
class |
Intersection<A>
|
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
|
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 |
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
|
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
|
| Modifier and Type | Method and Description |
|---|---|
static <A> Fn1<Maybe<A>,Maybe<A>> |
Absent.absent(Semigroup<A> aSemigroup,
Maybe<A> x) |
static <_1,_2> Fn1<Tuple2<_1,_2>,Tuple2<_1,_2>> |
Collapse.collapse(Semigroup<_1> _1Semigroup,
Semigroup<_2> _2Semigroup,
Tuple2<_1,_2> x) |
static <A> Fn1<CompletableFuture<A>,CompletableFuture<A>> |
Compose.compose(Semigroup<A> aSemigroup,
CompletableFuture<A> x) |
static <A> Fn1<Iterable<A>,Iterable<A>> |
Intersection.intersection(Iterable<A> xs) |
static <L,R> Fn1<Either<L,R>,Either<L,R>> |
LeftAll.leftAll(Semigroup<L> lSemigroup,
Either<L,R> x) |
static <L,R> Fn1<Either<L,R>,Either<L,R>> |
LeftAny.leftAny(Semigroup<L> lSemigroup,
Either<L,R> x) |
static <A extends Comparable<A>> |
Max.max(A x) |
static <A,B extends Comparable<B>> |
MaxBy.maxBy(Fn1<? super A,? extends B> compareFn,
A x) |
static <L,R> Fn1<Either<L,R>,Either<L,R>> |
Merge.merge(Semigroup<L> lSemigroup,
Semigroup<R> rSemigroup,
Either<L,R> x) |
static <A extends Comparable<A>> |
Min.min(A x) |
static <A,B extends Comparable<B>> |
MinBy.minBy(Fn1<? super A,? extends B> compareFn,
A x) |
static <L,R> Fn1<Either<L,R>,Either<L,R>> |
RightAll.rightAll(Semigroup<R> rSemigroup,
Either<L,R> x) |
static <L,R> Fn1<Either<L,R>,Either<L,R>> |
RightAny.rightAny(Semigroup<R> rSemigroup,
Either<L,R> x) |
static <A> Fn1<IO<A>,IO<A>> |
RunAll.runAll(Semigroup<A> semigroup,
IO<A> ioX) |
| Modifier and Type | Method and Description |
|---|---|
Semigroup<A> |
MinBy.checkedApply(Fn1<? super A,? extends B> compareFn) |
Semigroup<A> |
MaxBy.checkedApply(Fn1<? super A,? extends B> compareFn) |
static <A,B extends Comparable<B>> |
MaxBy.maxBy(Fn1<? super A,? extends B> compareFn) |
static <A,B extends Comparable<B>> |
MaxBy.maxBy(Fn1<? super A,? extends B> compareFn,
A x) |
static <A,B extends Comparable<B>> |
MaxBy.maxBy(Fn1<? super A,? extends B> compareFn,
A x,
A y) |
static <A,B extends Comparable<B>> |
MinBy.minBy(Fn1<? super A,? extends B> compareFn) |
static <A,B extends Comparable<B>> |
MinBy.minBy(Fn1<? super A,? extends B> compareFn,
A x) |
static <A,B extends Comparable<B>> |
MinBy.minBy(Fn1<? super A,? extends B> compareFn,
A x,
A y) |
| Modifier and Type | Method and Description |
|---|---|
<B> LambdaIterable<B> |
LambdaIterable.flatMap(Fn1<? super A,? extends Monad<B,LambdaIterable<?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
default <B> Traversable<B,T> |
Traversable.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> LambdaIterable<B> |
LambdaIterable.fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<C> LambdaMap<A,C> |
LambdaMap.fmap(Fn1<? super B,? extends C> fn) |
<B> LambdaIterable<B> |
LambdaIterable.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,LambdaIterable<?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,LambdaIterable<?>>,AppTrav extends Applicative<TravB,App>> |
LambdaIterable.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,LambdaIterable<?>>,AppTrav extends Applicative<TravB,App>> |
LambdaIterable.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,T>,AppTrav extends Applicative<TravB,App>> |
Traversable.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<B,App extends Applicative<?,App>,TravB extends Traversable<B,T>,AppTrav extends Applicative<TravB,App>> |
Traversable.traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
Fn1<? super TravB,? extends AppTrav> pure)
Apply
fn to each element of this traversable from left to right, and collapse the results into
a single resulting applicative, potentially with the assistance of the applicative's pure function. |
<C,App extends Applicative<?,App>,TravC extends Traversable<C,LambdaMap<A,?>>,AppTrav extends Applicative<TravC,App>> |
LambdaMap.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravC,? extends AppTrav> pure) |
<C,App extends Applicative<?,App>,TravC extends Traversable<C,LambdaMap<A,?>>,AppTrav extends Applicative<TravC,App>> |
LambdaMap.traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
Fn1<? super TravC,? extends AppTrav> pure) |
| Modifier and Type | Method and Description |
|---|---|
<B> Lazy<LambdaIterable<B>> |
LambdaIterable.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,LambdaIterable<?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B> LambdaIterable<B> |
LambdaIterable.zip(Applicative<Fn1<? super A,? extends B>,LambdaIterable<?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|