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

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

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

Modifier and Type

Method

Description

final <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.

final <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.

final <L2> Either<L2,R>

Either.biMapL(Fn1<? super L, ? extends L2> fn)

Covariantly map over the left parameter.

final <Z> These<Z,B>

These.biMapL(Fn1<? super A, ? extends Z> fn)

Covariantly map over the left parameter.

final <R2> Either<L,R2>

Either.biMapR(Fn1<? super R, ? extends R2> fn)

Covariantly map over the right parameter.

final <C> These<A,C>

These.biMapR(Fn1<? super B, ? extends C> fn)

Covariantly map over the right parameter.

Either<L,R>

Either.catchError(Fn1<? super L, ? extends Monad<R, Either<L,?>>> recoveryFn)

Catch any thrown errors inside the Monad and resume normal operations.

Maybe<A>

Maybe.catchError(Fn1<? super Unit, ? extends Monad<A,Maybe<?>>> recoveryFn)

Catch any thrown errors inside the Monad and resume normal operations.

Try<A>

Try.catchError(Fn1<? super Throwable, ? extends Monad<A,Try<?>>> recoveryFn)

Catch any thrown errors inside the Monad and resume normal operations.

final 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.

final <S extends Throwable> Try<A>

Try.catching(Class<S> throwableType, Fn1<? super S, ? extends A> recoveryFn)

Catch any instance of throwableType and map it to a success value.

final Either<L,R>

Either.filter(Fn1<? super R, ? extends Boolean> pred, Fn0<L> leftFn0)

If this is a right value, apply pred to it.

final 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.

final 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.

<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>.

final Maybe

Maybe.flatMap(Fn1<? super A, ? extends Monad<B,Maybe<?>>> f)

Chain dependent computations that may continue or short-circuit based on previous results.

final <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.

 Try

Try.flatMap(Fn1<? super A, ? extends Monad<B,Try<?>>> f)

Chain dependent computations that may continue or short-circuit based on previous results.

final <R2> Either<L,R2>

Either.fmap(Fn1<? super R, ? extends R2> fn)

Covariantly transmute this functor's parameter using the given mapping function.

final Maybe

Maybe.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

final <C> These<A,C>

These.fmap(Fn1<? super B, ? extends C> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 Try

Try.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

final L

Either.forfeit(Fn1<? super R, ? extends L> forfeitFn)

Inverse of recover.

final Throwable

Try.forfeit(Fn1<? super A, ? extends Throwable> fn)

If this is a failure, return the wrapped value.

<V> V

Either.Left.match(Fn1<? super L, ? extends V> leftFn, Fn1<? super R, ? extends V> rightFn)

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.

<V> V

Either.Right.match(Fn1<? super L, ? extends V> leftFn, Fn1<? super R, ? extends V> rightFn)

<R> R

Maybe.Just.match(Fn1<? super Unit, ? extends R> aFn, Fn1<? super A, ? extends R> bFn)

<R> R

Maybe.Nothing.match(Fn1<? super Unit, ? extends R> aFn, Fn1<? super A, ? extends R> bFn)

<R> R

These._A.match(Fn1<? super A, ? extends R> aFn, Fn1<? super B, ? extends R> bFn, Fn1<? super Tuple2<A,B>, ? extends R> cFn)

<R> R

These._B.match(Fn1<? super A, ? extends R> aFn, Fn1<? super B, ? extends R> bFn, Fn1<? super Tuple2<A,B>, ? extends R> cFn)

<R> R

These.Both.match(Fn1<? super A, ? extends R> aFn, Fn1<? super B, ? extends R> bFn, Fn1<? super Tuple2<A,B>, ? extends R> cFn)

<R> R

Try.Failure.match(Fn1<? super Throwable, ? extends R> aFn, Fn1<? super A, ? extends R> bFn)

<R> R

Try.Success.match(Fn1<? super Throwable, ? extends R> aFn, Fn1<? super A, ? extends R> bFn)

final <T extends Throwable> R

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.

<T extends Throwable> A

Try.Failure.orThrow(Fn1<? super Throwable, ? extends T> fn)

abstract <T extends Throwable> A

Try.orThrow(Fn1<? super Throwable, ? extends T> fn)

If this is a success value, return it.

<T extends Throwable> A

Try.Success.orThrow(Fn1<? super Throwable, ? extends T> fn)

Either<L,R>

Either.peek(Fn1<? super L, ? extends IO<?>> leftEffect, Fn1<? super R, ? extends IO<?>> rightEffect)

Deprecated.
in favor of matching into an IO and explicitly running it

Either<L,R>

Either.peek(Fn1<? super R, ? extends IO<?>> effect)

Deprecated.
in favor of matching into an IO and explicitly running it

final Maybe<A>

Maybe.peek(Fn1<? super A, ? extends IO<?>> effect)

Deprecated.
in favor of matching into an IO and explicitly running it

final 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.

final A

Try.recover(Fn1<? super Throwable, ? extends A> fn)

If this is a success, return the wrapped value.

final <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.

 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.

 Maybe

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.

<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.

 Try

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.

final <R2, App extends Applicative<?,App>, TravB extends Traversable<R2, Either<L,?>>, AppTrav extends Applicative<TravB,App>> AppTrav

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.

final <B, App extends Applicative<?,App>, TravB extends Traversable<B,Maybe<?>>, AppTrav extends Applicative<TravB,App>> AppTrav

Maybe.traverse(Fn1<? super A, ? extends Applicative<B,App>> fn, Fn1<? super TravB, ? extends AppTrav> pure)

<C, App extends Applicative<?,App>, TravC extends Traversable<C, These<A,?>>, AppTrav extends Applicative<TravC,App>> AppTrav

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.

<B, App extends Applicative<?,App>, TravB extends Traversable<B,Try<?>>, AppTrav extends Applicative<TravB,App>> AppTrav

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.

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<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<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

Try.withResources(Fn0<? extends A> fn0, Fn1<? super A, ? extends Try<? extends B>> fn)

Given a Fn0<AutoCloseable> 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.

Method parameters in com.jnape.palatable.lambda.adt with type arguments of type Fn1

Modifier and Type

Method

Description

<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.

 Lazy<Maybe>

Maybe.lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, Maybe<?>>> lazyAppFn)

Terminate early if this is a Maybe.Nothing; otherwise, continue the zip.

<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.

 Lazy<Try>

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.

final <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.

final Maybe

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.

final <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.

 Try

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.
Uses of Fn1 in com.jnape.palatable.lambda.adt.choice

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

Modifier and Type

Method

Description

final <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.

final <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.

final <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.

<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.

<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.

final <C> Choice2<C,B>

Choice2.biMapL(Fn1<? super A, ? extends C> fn)

Covariantly map over the left parameter.

final <D> Choice3<A,D,C>

Choice3.biMapL(Fn1<? super B, ? extends D> fn)

Covariantly map over the left parameter.

final <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.

 Choice8<A,B,C,D,E,F,I,H>

Choice8.biMapL(Fn1<? super G, ? extends I> fn)

Covariantly map over the left parameter.

final <C> Choice2<A,C>

Choice2.biMapR(Fn1<? super B, ? extends C> fn)

Covariantly map over the right parameter.

final <D> Choice3<A,B,D>

Choice3.biMapR(Fn1<? super C, ? extends D> fn)

Covariantly map over the right parameter.

final <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.

 Choice8<A,B,C,D,E,F,G,I>

Choice8.biMapR(Fn1<? super H, ? extends I> fn)

Covariantly map over the right parameter.

final 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.

final <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.

 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.

final <C> Choice2<A,C>

Choice2.fmap(Fn1<? super B, ? extends C> fn)

Covariantly transmute this functor's parameter using the given mapping function.

final <D> Choice3<A,B,D>

Choice3.fmap(Fn1<? super C, ? extends D> fn)

Covariantly transmute this functor's parameter using the given mapping function.

final <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.

 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.

<R> R

Choice2._A.match(Fn1<? super A, ? extends R> aFn, Fn1<? super B, ? extends R> bFn)

<R> R

Choice2._B.match(Fn1<? super A, ? extends R> aFn, Fn1<? super B, ? extends R> bFn)

<R> R

Choice3._A.match(Fn1<? super A, ? extends R> aFn, Fn1<? super B, ? extends R> bFn, Fn1<? super C, ? extends R> cFn)

<R> R

Choice3._B.match(Fn1<? super A, ? extends R> aFn, Fn1<? super B, ? extends R> bFn, Fn1<? super C, ? extends R> cFn)

<R> R

Choice3._C.match(Fn1<? super A, ? extends R> aFn, Fn1<? super B, ? extends R> bFn, Fn1<? super C, ? extends R> cFn)

<R> R

Choice4._A.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)

<R> R

Choice4._B.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)

<R> R

Choice4._C.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)

<R> R

Choice4._D.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)

<R> R

Choice5._A.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)

<R> R

Choice5._B.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)

<R> R

Choice5._C.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)

<R> R

Choice5._D.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)

<R> R

Choice5._E.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)

<R> R

Choice6._A.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)

<R> R

Choice6._B.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)

<R> R

Choice6._C.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)

<R> R

Choice6._D.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)

<R> R

Choice6._E.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)

<R> R

Choice6._F.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)

<R> R

Choice7._A.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)

<R> R

Choice7._B.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)

<R> R

Choice7._C.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)

<R> R

Choice7._D.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)

<R> R

Choice7._E.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)

<R> R

Choice7._F.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)

<R> R

Choice7._G.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)

<R> R

Choice8._A.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)

<R> R

Choice8._B.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)

<R> R

Choice8._C.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)

<R> R

Choice8._D.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)

<R> R

Choice8._E.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)

<R> R

Choice8._F.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)

<R> R

Choice8._G.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)

<R> R

Choice8._H.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)

<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.

 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>> AppTrav

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>> AppTrav

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>> AppTrav

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>> AppTrav

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>> AppTrav

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>> AppTrav

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>> AppTrav

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.

Method parameters in com.jnape.palatable.lambda.adt.choice with type arguments of type Fn1

Modifier and Type

Method

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.

 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.

 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.
Uses of Fn1 in com.jnape.palatable.lambda.adt.coproduct

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

Modifier and Type

Method

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

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

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

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.

<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

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

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

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.
Uses of Fn1 in com.jnape.palatable.lambda.adt.hlist

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

Modifier and Type

Method

Description

<_1Prime,_2Prime> Tuple2<_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<_1,_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<_1,_2,_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<_1,_2,_3,_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<_1,_2,_3,_4,_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<_1,_2,_3,_4,_5,_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<_1,_2,_3,_4,_5,_6,_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>> AppTrav

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>> AppTrav

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>> AppTrav

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>> AppTrav

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>> AppTrav

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>> AppTrav

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>> AppTrav

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>> AppTrav

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.

Method parameters in com.jnape.palatable.lambda.adt.hlist with type arguments of type Fn1

Modifier and Type

Method

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.
Uses of Fn1 in com.jnape.palatable.lambda.functions

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

Modifier and Type

Interface

Description

interface

Effect<A>

A function returning "no result", and therefore only useful as a side-effect.

interface

Fn0<A>

A function taking "no arguments", implemented as an Fn1<Unit, 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 seven arguments.

interface

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

A function taking eight arguments.

Subinterfaces with type arguments of type Fn1 in com.jnape.palatable.lambda.functions

Modifier and Type

Interface

Description

interface

Fn1<A,B>

A function taking a single argument.

interface

Fn1<A,B>

A function taking a single argument.

interface

Fn1<A,B>

A function taking a single argument.

interface

Fn1<A,B>

A function taking a single argument.

interface

Fn1<A,B>

A function taking a single argument.

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 seven arguments.

interface

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

A function taking eight arguments.

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

Modifier and Type

Method

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)

Left-to-right composition.

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)

Static factory method for wrapping a java Function in an Fn1.

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 Fn1<A,B>

Fn1.self()

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()

Returns an Fn1 that takes the arguments as a Product2<A, B>.

static <A,B> Fn1<A,B>

Fn1.withSelf(Fn2<? super Fn1<? super A, ? extends B>, ? super A, ? extends B> fn)

Construct an Fn1 that has a reference to itself in scope at the time it is executed (presumably for recursive invocations).

default <C> Fn1<A,C>

Fn1.zip(Fn2<A,B,C> 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.

Methods in com.jnape.palatable.lambda.functions that return types with arguments of type Fn1

Modifier and Type

Method

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()

The canonical Pure instance for Fn1.

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

Modifier and Type

Method

Description

default Fn1<A,B>

Fn1.censor(Fn1<? super A, ? extends A> fn)

Update the accumulated state.

default <Z> Effect<Z>

Effect.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> Fn2<Z,B,C>

Fn2.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> Fn4<Z,B,C,D,E>

Fn4.contraMap(Fn1<? super Z, ? extends A> fn)

default <Z> Fn5<Z,B,C,D,E,F>

Fn5.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)

default <Z> Fn8<Z,B,C,D,E,F,G,H,I>

Fn8.contraMap(Fn1<? super Z, ? extends A> fn)

static <A,B,C> Fn2<A,B,C>

Fn2.curried(Fn1<A,Fn1<B,C>> curriedFn1)

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

static <A,B,C> Fn2<A,B,C>

Fn2.curry(Fn1<? super Tuple2<A,B>, ? extends C> uncurriedFn1)

Static factory method for wrapping an uncurried Fn1 in an Fn2.

default <Z,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> 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> 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> 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> Fn3<Z,B,C,D>

Fn3.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> Fn5<Z,B,C,D,E,F>

Fn5.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 <Z> Fn8<Z,B,C,D,E,F,G,H,I>

Fn8.diMapL(Fn1<? super Z, ? extends A> fn)

default Fn0

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)

Create an Effect from an Fn1 that yields an IO.

default Fn0

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 Fn0

Fn0.fmap(Fn1<? super A, ? extends B> f)

default <C> Fn1<A,C>

Fn1.fmap(Fn1<? super B, ? extends C> f)

Left-to-right composition.

static <A> Fn0<A>

Fn0.fn0(Fn1<Unit,A> fn)

Static factory method for adapting an Fn1<Unit, A> to an Fn0<A>.

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 factory method for wrapping a curried Fn1 in an Fn3.

static <A,B,C,D,E> Fn4<A,B,C,D,E>

Fn4.fn4(Fn1<A, Fn3<B,C,D,E>> curriedFn1)

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

static <A,B,C,D,E,F> Fn5<A,B,C,D,E,F>

Fn5.fn5(Fn1<A, Fn4<B,C,D,E,F>> curriedFn1)

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

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

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

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

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

Fn7.fn7(Fn1<A, Fn6<B,C,D,E,F,G,H>> curriedFn1)

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

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

Fn8.fn8(Fn1<A, Fn7<B,C,D,E,F,G,H,I>> curriedFn1)

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

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.

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

Modifier and Type

Method

Description

static <A,B,C> Fn2<A,B,C>

Fn2.curried(Fn1<A,Fn1<B,C>> curriedFn1)

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

default Fn0

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 <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 Fn0<A>

Fn0.discardR(Applicative<B, Fn1<Unit,?>> 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 <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 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 Fn0

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 factory method for wrapping a curried Fn2 in an Fn3.

static <A,B,C,D,E> Fn4<A,B,C,D,E>

Fn4.fn4(Fn3<A,B,C,Fn1<D,E>> curriedFn3)

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

static <A,B,C,D,E,F> Fn5<A,B,C,D,E,F>

Fn5.fn5(Fn4<A,B,C,D,Fn1<E,F>> curriedFn4)

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

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

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

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

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

Fn7.fn7(Fn6<A,B,C,D,E,F,Fn1<G,H>> curriedFn6)

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

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

Fn8.fn8(Fn7<A,B,C,D,E,F,G,Fn1<H,I>> curriedFn7)

Static factory method for wrapping a curried Fn7 in an Fn8.

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.

static <A,B> Fn1<A,B>

Fn1.withSelf(Fn2<? super Fn1<? super A, ? extends B>, ? super A, ? extends B> fn)

Construct an Fn1 that has a reference to itself in scope at the time it is executed (presumably for recursive invocations).

default Fn0

Fn0.zip(Applicative<Fn1<? super A, ? extends B>, Fn1<Unit,?>> appFn)

default Fn0

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.
Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn1

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

Modifier and Type

Class

Description

final class

CatMaybes<A>

Given an Iterable<Maybe<A>>, return an Iterable<A> of only the present values.

final class

Coalesce<L,R>

Fold an Iterable<Either<L, R>> into an Either<Iterable<L>, Iterable<R>>, preserving all results of the side that's returned.

final class

Constantly<A,B>

A function that takes two arguments and always returns the first argument.

final class

Cycle<A>

Given an Iterable, return an infinite Iterable that repeatedly cycles its elements, in order.

final class

Distinct<A>

Return an Iterable of the distinct values from the given input Iterable.

final class

Downcast<A extends B, B>

Covariantly cast a value of type B to a value of subtype A.

final class

Empty<A>

A predicate that returns true if as is empty; false otherwise.

final class

Flatten<A>

Given a nested Iterable of Iterables, return a lazily flattening Iterable of the nested elements.

final class

Force<A>

Deprecated.
in favor of traversing into an IO and running it

final class

Head<A>

Retrieve the head element of an Iterable, wrapped in an Maybe.

final class

Id<A>

The identity function.

final class

Init<A>

Given an Iterable<A>, produce an Iterable<A> of all elements but the last one.

final class

Inits<A>

Given an Iterable<A>, produce an Iterable<Iterable<A>>, representing all of the subsequences of initial elements, ordered by size, starting with the empty Iterable.

final class

Last<A>

Retrieve the last element of an Iterable, wrapped in a Maybe.

final class

Magnetize<A>

Magnetize an Iterable using value equality as the magnetizing function.

final class

Not<A>

Negate a predicate function.

final class

Occurrences<A>

Given an Iterable<A>, return a Map<A, Long> representing each unique element in the Iterable paired with its number of occurrences.

final class

Repeat<A>

Given a value, return an infinite Iterable that repeatedly iterates that value.

final class

Reverse<A>

Given an Iterable, return a reversed representation of that Iterable.

final class

Size

final class

Sort<A extends Comparable<A>>

Given an Iterable of Comparable elements, return a List of the sorted elements.

final class

Tail<A>

Returns the tail of an Iterable; the is, an Iterable of all the elements except for the head element.

final class

Tails<A>

Given an Iterable<A>, produce an Iterable<Iterable<A>>, representing all of the subsequences of tail elements, ordered by size, starting with the full Iterable.

final class

Uncons<A>

Destructure an Iterable into a Tuple2 of its head and tail, wrapped in an Maybe.

final class

Upcast<A extends B, B>

Upcast a value of type B to a value of type A that B extends.

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

Modifier and Type

Class

Description

final class

Not<A>

Negate a predicate function.

Methods in com.jnape.palatable.lambda.functions.builtin.fn1 that return Fn1

Modifier and Type

Method

Description

static <A,B> Fn1<B,A>

Constantly.constantly(A a)

Methods in com.jnape.palatable.lambda.functions.builtin.fn1 with parameters of type Fn1

Modifier and Type

Method

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)
Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn2

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

Modifier and Type

Class

Description

final class

$<A,B>

Function application, represented as a higher-order Fn2 that receives an Fn1 and its argument, and applies it.

final class

All<A>

Eagerly apply a predicate to each element in an Iterable, returning true if every element satisfies the predicate, and false otherwise.

final class

Alter<A>

Given an Effect<A> and some A, produce an IO that, when run, performs the effect on A and returns it.

final class

Any<A>

Eagerly apply a predicate to each element in an Iterable, returning true if any element satisfies the predicate, and false otherwise.

final class

AutoBracket<A extends AutoCloseable, B>

Given an IO yielding some AutoCloseable type A and a kleisli arrow from that type to a new IO of type B, attempt to provision the A, applying the body operation if provisioning was successful and ensuring that AutoCloseable.close() is called regardless of whether the body succeeds or fails.

final class

Both<A,B,C>

Given two functions f and g, produce a Fn1<A, Tuple2<B, C>> (the dual application of both functions).

final class

CartesianProduct<A,B>

Lazily compute the cartesian product of an Iterable<A> and Iterable, returning an Iterable<Tuple2<A, B>>, the products as tuples of multiplicand As and multiplier Bs.

final class

CmpEq<A extends Comparable<A>>

Given two Comparable values of type A, return true if the first value is strictly equal to the second value (according to Comparable.compareTo(Object); otherwise, return false.

final class

Cons<A>

Prepend an element to an Iterable.

final class

Difference<A>

Given two Iterables xs and ys, return the distinct elements of xs that are not in ys.

final class

Drop<A>

Lazily skip the first n elements from an Iterable by returning an Iterable that begins iteration after the nth element.

final class

DropWhile<A>

Lazily limit the Iterable by skipping the first contiguous group of elements that satisfy the predicate, beginning iteration at the first element for which the predicate evaluates to false.

final class

Eq<A>

Type-safe equality in function form; uses Object.equals(Object), not ==.

final class

Filter<A>

Lazily apply a predicate to each element in an Iterable, returning an Iterable of just the elements for which the predicate evaluated to true.

final class

Find<A>

Iterate the elements in an Iterable, applying a predicate to each one, returning the first element that matches the predicate, wrapped in a Maybe.

final class

GroupBy<K,V>

Given an Iterable<V> vs and a key function V -> K f, fold vs into a Map<K, List<V>> by applying f to each element of vs, retaining values that map to the same key in a list, in the order they were iterated in.

final class

GT<A extends Comparable<A>>

Given two Comparable values of type A, return true if the second value is strictly greater than the first value; otherwise, return false.

final class

GTE<A extends Comparable<A>>

Given two Comparable values of type A, return true if the second value is greater than or equal to the first value according to Comparable.compareTo(Object); otherwise, return false.

final class

InGroupsOf<A>

Lazily group the Iterable by returning an Iterable of smaller Iterables of size k.

final class

Intersperse<A>

Lazily inject the provided separator value between each value in the supplied Iterable.

final class

Into<A,B,C>

Given an Fn2<A, B, C> and a Map.Entry<A, B>, destructure the entry and apply the key and value as arguments to the function, returning the result.

final class

Into1<A,B>

Given an Fn1<A, B> and a SingletonHList<A>, pop the head and apply it to the function, returning the result.

final class

Into3<A,B,C,D>

Given an Fn3<A, B, C, D> and a Product3<A, B, C>, destructure the product and apply the slots as arguments to the function, returning the result.

final class

Into4<A,B,C,D,E>

Given an Fn4<A, B, C, D, E> and a Product4<A, B, C, D>, destructure the product and apply the slots as arguments to the function, returning the result.

final class

Into5<A,B,C,D,E,F>

Given an Fn5<A, B, C, D, E, F> and a Product5<A, B, C, D, E>, destructure the product and apply the slots as arguments to the function, returning the result.

final class

Into6<A,B,C,D,E,F,G>

Given an Fn6<A, B, C, D, E, F, G> and a Product6<A, B, C, D, E, F>, destructure the product and apply the slots as arguments to the function, returning the result.

final class

Into7<A,B,C,D,E,F,G,H>

Given an Fn7<A, B, C, D, E, F, G, H> and a Product7<A, B, C, D, E, F, G>, destructure the product and apply the slots as arguments to the function, returning the result.

final class

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

Given an Fn8<A, B, C, D, E, F, G, H, I> and a Product8<A, B, C, D, E, F, G, H>, destructure the product and apply the slots as arguments to the function, returning the result.

final class

Iterate<A>

Lazily generate an infinite Iterable from the successive applications of the function first to the initial seed value, then to the result, and so on; i.e., the result of iterate(x -> x + 1, 0) would produce an infinite Iterable over the elements 0, 1, 2, 3, ...

final class

LazyRec<A,B>

Given a Fn2 that receives a recursive function and an input and yields a lazy result, and an input, produce a lazy result that, when forced, will recursively invoke the function until it terminates in a stack-safe way.

final class

LT<A extends Comparable<A>>

Given two Comparable values of type A, return true if the second value is strictly less than the first value; otherwise, return false.

final class

LTE<A extends Comparable<A>>

Given two Comparable values of type A, return true if the second value is less than or equal to the first value according to Comparable.compareTo(Object) otherwise, return false.

final class

MagnetizeBy<A>

Given a binary predicate and an Iterable<A>, return an Iterable<Iterable<A>> of the contiguous groups of elements that match the predicate pairwise.

final class

Map<A,B>

Lazily apply a function to each element in an Iterable, producing an Iterable of the mapped results.

final class

Partition<A,B,C>

Given an Iterable<A> as and a disjoint mapping function a -> CoProduct2<A, B>, return a Tuple2 over the lazily unwrapped left A and right B values in the first and second slots, respectively.

final class

Peek<A, FA extends Functor<A,?>>

Deprecated.
in favor of producing an IO from the given Functor and explicitly running it

final class

Peek2<A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>>

Deprecated.
in favor of producing an IO from the given BoundedBifunctor and explicitly running it

final class

PrependAll<A>

Lazily prepend each value with of the Iterable with the supplied separator value.

final class

ReduceLeft<A>

Given an Iterable<A> and a Fn2<A, A, A>, iteratively accumulate over the Iterable, returning Maybe<A>.

final class

ReduceRight<A>

Given an Iterable<A> and a Fn2<A, A, A>, iteratively accumulate over the Iterable, returning Maybe<A>.

final class

Replicate<A>

Produce an Iterable of a value n times.

final class

Sequence<A, App extends Applicative<?,App>, Trav extends Traversable<?,Trav>, TravA extends Traversable<A,Trav>, AppTrav extends Applicative<TravA,App>>

Given a Traversable of Applicatives and a pure Applicative constructor, traverse the elements from left to right, zipping the Applicatives together and collecting the results.

final class

Slide<A>

Given an Iterable<A>, "slide" a window of k elements across the Iterable by one element at a time, returning an Iterable<Iterable<A>>.

final class

Snoc<A>

Opposite of Cons: lazily append an element to the end of the given Iterable.

final class

SortBy<A, B extends Comparable>

Given an Iterable and some mapping function from the Iterable element type to some Comparable type, produce a sorted List of the original elements based on sorting applied to the result of the mapping function.

final class

SortWith<A>

Given an Iterable and a Comparator over the Iterable element type, produce a sorted List of the original elements based on sorting applied by the Comparator.

final class

Span<A>

Given a predicate, return a Tuple2 where the first slot is the front contiguous elements of an Iterable matching the predicate and the second slot is all the remaining elements.

final class

Take<A>

Lazily limit the Iterable to n elements by returning an Iterable that stops iteration after the nth element, or the last element of the Iterable, whichever comes first.

final class

TakeWhile<A>

Lazily limit the Iterable to the first group of contiguous elements that satisfy the predicate by iterating up to, but not including, the first element for which the predicate evaluates to false.

final class

ToArray<A>

Write all the elements of an Iterable directly into an array of the specified type.

final class

ToCollection<A, C extends Collection<A>>

Given an Fn0 of some Collection C, create an instance of C and add all of the elements in the provided Iterable to the instance.

final class

ToMap<K, V, M extends Map<K,V>>

Given an Fn0 of some Map M, create an instance of M and put all of the entries in the provided Iterable into the instance.

final class

Tupler2<A,B>

Creates a Tuple2 from two values.

final class

Unfoldr<A,B>

Given an initial seed value and a function that takes the seed type and produces an Maybe<Tuple2<X, Seed>>, where the tuple's first slot represents the next Iterable element, and the second slot represents the next input to the unfolding function, unfold an Iterable of Xs.

final class

Until<A>

Given a predicate function for a value of some type A and an IO that yields a value of type A, produce an IO that repeatedly executes the original IO until the predicate returns true when applied to the yielded value.

final class

Zip<A,B>

Zip together two Iterables into a single Iterable of Tuple2<A, B>.

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

Modifier and Type

Class

Description

final class

$<A,B>

Function application, represented as a higher-order Fn2 that receives an Fn1 and its argument, and applies it.

final class

All<A>

Eagerly apply a predicate to each element in an Iterable, returning true if every element satisfies the predicate, and false otherwise.

final class

Alter<A>

Given an Effect<A> and some A, produce an IO that, when run, performs the effect on A and returns it.

final class

Any<A>

Eagerly apply a predicate to each element in an Iterable, returning true if any element satisfies the predicate, and false otherwise.

final class

AutoBracket<A extends AutoCloseable, B>

Given an IO yielding some AutoCloseable type A and a kleisli arrow from that type to a new IO of type B, attempt to provision the A, applying the body operation if provisioning was successful and ensuring that AutoCloseable.close() is called regardless of whether the body succeeds or fails.

final class

Both<A,B,C>

Given two functions f and g, produce a Fn1<A, Tuple2<B, C>> (the dual application of both functions).

final class

Both<A,B,C>

Given two functions f and g, produce a Fn1<A, Tuple2<B, C>> (the dual application of both functions).

final class

DropWhile<A>

Lazily limit the Iterable by skipping the first contiguous group of elements that satisfy the predicate, beginning iteration at the first element for which the predicate evaluates to false.

final class

Filter<A>

Lazily apply a predicate to each element in an Iterable, returning an Iterable of just the elements for which the predicate evaluated to true.

final class

Find<A>

Iterate the elements in an Iterable, applying a predicate to each one, returning the first element that matches the predicate, wrapped in a Maybe.

final class

GroupBy<K,V>

Given an Iterable<V> vs and a key function V -> K f, fold vs into a Map<K, List<V>> by applying f to each element of vs, retaining values that map to the same key in a list, in the order they were iterated in.

final class

Into1<A,B>

Given an Fn1<A, B> and a SingletonHList<A>, pop the head and apply it to the function, returning the result.

final class

Iterate<A>

Lazily generate an infinite Iterable from the successive applications of the function first to the initial seed value, then to the result, and so on; i.e., the result of iterate(x -> x + 1, 0) would produce an infinite Iterable over the elements 0, 1, 2, 3, ...

final class

Map<A,B>

Lazily apply a function to each element in an Iterable, producing an Iterable of the mapped results.

final class

Partition<A,B,C>

Given an Iterable<A> as and a disjoint mapping function a -> CoProduct2<A, B>, return a Tuple2 over the lazily unwrapped left A and right B values in the first and second slots, respectively.

final class

Peek<A, FA extends Functor<A,?>>

Deprecated.
in favor of producing an IO from the given Functor and explicitly running it

final class

Peek2<A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>>

Deprecated.
in favor of producing an IO from the given BoundedBifunctor and explicitly running it

final class

Peek2<A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>>

Deprecated.
in favor of producing an IO from the given BoundedBifunctor and explicitly running it

final class

Sequence<A, App extends Applicative<?,App>, Trav extends Traversable<?,Trav>, TravA extends Traversable<A,Trav>, AppTrav extends Applicative<TravA,App>>

Given a Traversable of Applicatives and a pure Applicative constructor, traverse the elements from left to right, zipping the Applicatives together and collecting the results.

final class

SortBy<A, B extends Comparable>

Given an Iterable and some mapping function from the Iterable element type to some Comparable type, produce a sorted List of the original elements based on sorting applied to the result of the mapping function.

final class

Span<A>

Given a predicate, return a Tuple2 where the first slot is the front contiguous elements of an Iterable matching the predicate and the second slot is all the remaining elements.

final class

TakeWhile<A>

Lazily limit the Iterable to the first group of contiguous elements that satisfy the predicate by iterating up to, but not including, the first element for which the predicate evaluates to false.

final class

Unfoldr<A,B>

Given an initial seed value and a function that takes the seed type and produces an Maybe<Tuple2<X, Seed>>, where the tuple's first slot represents the next Iterable element, and the second slot represents the next input to the unfolding function, unfold an Iterable of Xs.

final class

Until<A>

Given a predicate function for a value of some type A and an IO that yields a value of type A, produce an IO that repeatedly executes the original IO until the predicate returns true when applied to the yielded value.

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

Modifier and Type

Method

Description

static <A,B> Fn1<A,B>

$.$(Fn1<? super A, ? extends B> fn)

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> Fn1<Fn1<? super A, ? extends IO>, IO>

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, 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> Fn1<Product4<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> Fn1<Product5<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> Fn1<Product6<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> Fn1<Product7<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> Fn1<Product8<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>

Map.map(Fn1<? super A, ? extends B> fn)

static <A,B,C> Fn1<Iterable<A>, Tuple2<Iterable, Iterable<C>>>

Partition.partition(Fn1<? super A, ? extends CoProduct2<B,C,?>> function)

static <A, FA extends Functor<A,?>> Fn1<FA,FA>

Peek.peek(Fn1<? super A, ? extends IO<?>> effect)

Deprecated.

static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> Fn1<FAB,FAB>

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>, Trav extends Traversable<?,Trav>, TravA extends Traversable<A,Trav>, AppTrav extends Applicative<TravA,App>> Fn1<Fn1<TravA, ? extends AppTrav>, AppTrav>

Sequence.sequence(Traversable<? extends Applicative<A,App>, Trav> traversable)

static <A, App extends Applicative<?,App>, AppIterable extends Applicative<Iterable<A>, App>> Fn1<Fn1<Iterable<A>, ? extends AppIterable>, AppIterable>

Sequence.sequence(Iterable<? extends Applicative<A,App>> iterableApp)

static <A, B, App extends Applicative<?,App>, AppMap extends Applicative<Map<A,B>,App>> Fn1<Fn1<Map<A,B>, ? extends AppMap>, AppMap>

Sequence.sequence(Map<A, ? extends Applicative<B,App>> mapApp)

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> Fn1<Iterable<A>, List<A>>

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>> Fn1<Iterable<A>, C>

ToCollection.toCollection(Fn0<C> cFn0)

static <K, V, M extends Map<K,V>> Fn1<Iterable<? extends Map.Entry<K,V>>, M>

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, Iterable<Tuple2<A,B>>>

Zip.zip(Iterable<A> as)

Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return types with arguments of type Fn1

Modifier and Type

Method

Description

static <A extends AutoCloseable, B> Fn1<Fn1<? super A, ? extends IO>, IO>

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, ?>> Fn2<Fn1<? super B, ? extends IO<?>>, FAB, FAB>

Peek2.peek2(Fn1<? super A, ? extends IO<?>> effectA)

Deprecated.

static <A, App extends Applicative<?,App>, Trav extends Traversable<?,Trav>, TravA extends Traversable<A,Trav>, AppTrav extends Applicative<TravA,App>> Fn1<Fn1<TravA, ? extends AppTrav>, AppTrav>

Sequence.sequence(Traversable<? extends Applicative<A,App>, Trav> traversable)

static <A, App extends Applicative<?,App>, AppIterable extends Applicative<Iterable<A>, App>> Fn1<Fn1<Iterable<A>, ? extends AppIterable>, AppIterable>

Sequence.sequence(Iterable<? extends Applicative<A,App>> iterableApp)

static <A, B, App extends Applicative<?,App>, AppMap extends Applicative<Map<A,B>,App>> Fn1<Fn1<Map<A,B>, ? extends AppMap>, AppMap>

Sequence.sequence(Map<A, ? extends Applicative<B,App>> mapApp)

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

Modifier and Type

Method

Description

static <A,B> Fn1<A,B>

$.$(Fn1<? super A, ? extends B> fn)

static <A,B> B

$.$(Fn1<? super A, ? extends B> fn, A a)

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> IO

AutoBracket.autoBracket(IO<A> io, Fn1<? super A, ? extends IO> 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> Tuple2<B,C>

Both.both(Fn1<? super A, ? extends B> f, Fn1<? super A, ? extends C> g, A a)

B

$.checkedApply(Fn1<? super A, ? extends B> fn, A a)

Boolean

All.checkedApply(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as)

IO<A>

Alter.checkedApply(Fn1<? super A, ? extends IO<?>> effect, A a)

Boolean

Any.checkedApply(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as)

IO

AutoBracket.checkedApply(IO<A> io, Fn1<? super A, ? extends IO> bodyIO)

Tuple2<B,C>

Both.checkedApply(Fn1<? super A, ? extends B> f, Fn1<? super A, ? extends C> g, A a)

Iterable<A>

DropWhile.checkedApply(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as)

Iterable<A>

Filter.checkedApply(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as)

Maybe<A>

Find.checkedApply(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as)

Map<K,List<V>>

GroupBy.checkedApply(Fn1<? super V, ? extends K> keyFn, Iterable<V> vs)

B

Into1.checkedApply(Fn1<? super A, ? extends B> fn, SingletonHList<A> singletonHList)

Iterable<A>

Iterate.checkedApply(Fn1<? super A, ? extends A> fn, A seed)

Iterable

Map.checkedApply(Fn1<? super A, ? extends B> fn, Iterable<A> as)

Tuple2<Iterable, Iterable<C>>

Partition.checkedApply(Fn1<? super A, ? extends CoProduct2<B,C,?>> function, Iterable<A> as)

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.

AppTrav

Sequence.checkedApply(Traversable<? extends Applicative<A,App>, Trav> traversable, Fn1<TravA, ? extends AppTrav> pure)

List<A>

SortBy.checkedApply(Fn1<? super A, ? extends B> fn, Iterable<A> as)

Tuple2<Iterable<A>, Iterable<A>>

Span.checkedApply(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as)

Iterable<A>

TakeWhile.checkedApply(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as)

Iterable<A>

Unfoldr.checkedApply(Fn1<? super B, Maybe<Tuple2<A,B>>> fn, B b)

IO<A>

Until.checkedApply(Fn1<? super A, ? extends Boolean> pred, IO<A> io)

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>

Map.map(Fn1<? super A, ? extends B> fn)

static <A,B> Iterable

Map.map(Fn1<? super A, ? extends B> fn, Iterable<A> as)

static <A,B,C> Fn1<Iterable<A>, Tuple2<Iterable, Iterable<C>>>

Partition.partition(Fn1<? super A, ? extends CoProduct2<B,C,?>> function)

static <A,B,C> Tuple2<Iterable, Iterable<C>>

Partition.partition(Fn1<? super A, ? extends CoProduct2<B,C,?>> function, Iterable<A> as)

static <A, FA extends Functor<A,?>> Fn1<FA,FA>

Peek.peek(Fn1<? super A, ? extends IO<?>> effect)

Deprecated.

static <A, FA extends Functor<A,?>> FA

Peek.peek(Fn1<? super A, ? extends IO<?>> effect, FA fa)

Deprecated.

static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> Fn2<Fn1<? super B, ? extends IO<?>>, FAB, FAB>

Peek2.peek2(Fn1<? super A, ? extends IO<?>> effectA)

Deprecated.

static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> Fn1<FAB,FAB>

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, ?>> FAB

Peek2.peek2(Fn1<? super A, ? extends IO<?>> effectA, Fn1<? super B, ? extends IO<?>> effectB, FAB fab)

Deprecated.

static <A, App extends Applicative<?,App>, Trav extends Traversable<?,Trav>, TravA extends Traversable<A,Trav>, AppTrav extends Applicative<TravA,App>> AppTrav

Sequence.sequence(Traversable<? extends Applicative<A,App>, Trav> traversable, Fn1<TravA, ? extends AppTrav> pure)

static <A, App extends Applicative<?,App>, AppIterable extends Applicative<Iterable<A>, App>> AppIterable

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>> AppMap

Sequence.sequence(Map<A, ? extends Applicative<B,App>> mapApp, Fn1<Map<A,B>, ? extends AppMap> pure)

static <A, B extends Comparable> Fn1<Iterable<A>, List<A>>

SortBy.sortBy(Fn1<? super A, ? extends B> fn)

static <A, B extends Comparable> List<A>

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)
Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn3

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

Modifier and Type

Class

Description

final class

Between<A extends Comparable<A>>

Given two bounds and a value, return whether or not the value is greater than or equal to the lower bound and less than or equal to the upper bound.

final class

Bracket<A,B>

Given an IO that yields some type A, a cleanup operation to run if a value of that type could be provisioned, and a kleisli arrow from that type to a new IO of type B, produce an IO that, when run, will provision the A, flatMap it to B, and clean up the original value if it was produced in the first place.

final class

Clamp<A extends Comparable<A>>

Given two bounds and a value, "clamp" the value between the bounds via the following algorithm: - if the value is strictly less than the lower bound, return the lower bound - if the value is strictly greater than the upper bound, return the upper bound - otherwise, return the value

final class

CmpEqBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the first value is strictly equal to the second value (according to Comparable.compareTo(Object) in terms of their mapped B results; otherwise, return false.

final class

CmpEqWith<A>

Given a Comparator from some type A and two values of type A, return true if the first value is strictly equal to the second value (according to Comparator.compare(Object, Object) otherwise, return false.

final class

Compare<A>

Given a Comparator from some type A and two values of type A, return a ComparisonRelation of the first value with reference to the second value (according to Comparator.compare(Object, Object).

final class

FoldLeft<A,B>

Given an Iterable of As, a starting value B, and a Fn2<B, A, B>, iteratively accumulate over the Iterable, ultimately returning a final B value.

final class

FoldRight<A,B>

Given an Iterable of As, a starting lazy value B, and a Fn2<A, Lazy, Lazy>, iteratively accumulate over the Iterable, ultimately returning a final Lazy value.

final class

GTBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is strictly greater than the first value in terms of their mapped B results; otherwise, return false.

final class

GTEBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is greater than or equal to the first value in terms of their mapped B results according to Comparable.compareTo(Object); otherwise, return false.

final class

GTEWith<A>

Given a Comparator from some type A and two values of type A, return true if the second value is greater than or equal to the first value in terms of their mapped B results according to Comparator.compare(Object, Object); otherwise, return false.

final class

GTWith<A>

Given a Comparator from some type A and two values of type A, return true if the second value is strictly greater than the first value in terms of their mapped B results; otherwise, return false.

final class

LiftA2<A, B, C, App extends Applicative<?,App>, AppC extends Applicative<C,App>>

Lift into and apply an Fn2 to two Applicative values, returning the result inside the same Applicative context.

final class

LTBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is strictly less than the first value in terms of their mapped B results; otherwise, return false.

final class

LTEBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is less than or equal to the first value in terms of their mapped B results according to Comparable.compareTo(Object); otherwise, return false.

final class

LTEWith<A>

Given a Comparator from some type A and two values of type A, return true if the second value is less than or equal to the first value in terms of their mapped B results according to Comparator.compare(Object, Object); otherwise, return false.

final class

LTWith<A>

Given a comparator for some type A and two values of type A, return true if the second value is strictly less than than the first value in terms of their mapped B results; otherwise, return false.

final class

ScanLeft<A,B>

Given an Iterable of As, a starting value B, and a Fn2<B, A, B>, iteratively accumulate over the Iterable, collecting each function application result, finally returning an Iterable of all the results.

final class

Times<A>

Given some number of times n to invoke a function A -> A, and given an input A, iteratively apply the function to the input, and then to the result of the invocation, a total of n times, returning the result.

final class

ZipWith<A,B,C>

Zip together two Iterables by applying a zipping function to the successive elements of each Iterable until one of them runs out of elements.

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

Modifier and Type

Class

Description

final class

Bracket<A,B>

Given an IO that yields some type A, a cleanup operation to run if a value of that type could be provisioned, and a kleisli arrow from that type to a new IO of type B, produce an IO that, when run, will provision the A, flatMap it to B, and clean up the original value if it was produced in the first place.

final class

Bracket<A,B>

Given an IO that yields some type A, a cleanup operation to run if a value of that type could be provisioned, and a kleisli arrow from that type to a new IO of type B, produce an IO that, when run, will provision the A, flatMap it to B, and clean up the original value if it was produced in the first place.

final class

CmpEqBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the first value is strictly equal to the second value (according to Comparable.compareTo(Object) in terms of their mapped B results; otherwise, return false.

final class

GTBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is strictly greater than the first value in terms of their mapped B results; otherwise, return false.

final class

GTEBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is greater than or equal to the first value in terms of their mapped B results according to Comparable.compareTo(Object); otherwise, return false.

final class

LTBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is strictly less than the first value in terms of their mapped B results; otherwise, return false.

final class

LTEBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B and two values of type A, return true if the second value is less than or equal to the first value in terms of their mapped B results according to Comparable.compareTo(Object); otherwise, return false.

final class

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.

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

Modifier and Type

Method

Description

static <A,B> Fn1<Fn1<? super A, ? extends IO>, IO>

Bracket.bracket(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO)

static <A extends Comparable<A>> Fn1<A,A>

Clamp.clamp(A lower, A upper)

static <A> Fn1<A, ComparisonRelation>

Compare.compare(Comparator<A> comparator, A a)

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>

FoldRight.foldRight(Fn2<? super A, ? super Lazy, ? extends Lazy> fn, Lazy acc)

static <A, B, C, App extends Applicative<?,App>, AppC extends Applicative<C,App>> Fn1<Applicative<B,App>, AppC>

LiftA2.liftA2(Fn2<? super A, ? super B, ? extends C> fn, Applicative<A,App> appA)

static <A,B> Fn1<Iterable<A>, Iterable>

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, Iterable<C>>

ZipWith.zipWith(Fn2<? super A, ? super B, ? extends C> zipper, Iterable<A> as)

Methods in com.jnape.palatable.lambda.functions.builtin.fn3 that return types with arguments of type Fn1

Modifier and Type

Method

Description

static <A,B> Fn2<Fn1<? super A, ? extends IO<?>>, Fn1<? super A, ? extends IO>, IO>

Bracket.bracket(IO<A> io)

static <A,B> Fn2<Fn1<? super A, ? extends IO<?>>, Fn1<? super A, ? extends IO>, IO>

Bracket.bracket(IO<A> io)

static <A,B> Fn1<Fn1<? super A, ? extends IO>, IO>

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)

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

Modifier and Type

Method

Description

BiPredicate<A,A>

CmpEqBy.apply(Fn1<? super A, ? extends B> compareFn)

Predicate<A>

CmpEqBy.apply(Fn1<? super A, ? extends B> compareFn, A x)

BiPredicate<A,A>

GTBy.apply(Fn1<? super A, ? extends B> compareFn)

Predicate<A>

GTBy.apply(Fn1<? super A, ? extends B> compareFn, A x)

BiPredicate<A,A>

GTEBy.apply(Fn1<? super A, ? extends B> compareFn)

Predicate<A>

GTEBy.apply(Fn1<? super A, ? extends B> compareFn, A y)

BiPredicate<A,A>

LTBy.apply(Fn1<? super A, ? extends B> compareFn)

Predicate<A>

LTBy.apply(Fn1<? super A, ? extends B> compareFn, A y)

BiPredicate<A,A>

LTEBy.apply(Fn1<? super A, ? extends B> compareFn)

Predicate<A>

LTEBy.apply(Fn1<? super A, ? extends B> compareFn, A y)

static <A,B> Fn1<Fn1<? super A, ? extends IO>, IO>

Bracket.bracket(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO)

static <A,B> IO

Bracket.bracket(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO, Fn1<? super A, ? extends IO> bodyIO)

IO

Bracket.checkedApply(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO, Fn1<? super A, ? extends IO> bodyIO)

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

GTEBy.checkedApply(Fn1<? super A, ? extends B> compareFn, A y, A x)

Boolean

LTBy.checkedApply(Fn1<? super A, ? extends B> compareFn, A y, A x)

Boolean

LTEBy.checkedApply(Fn1<? super A, ? extends B> compareFn, A y, A x)

A

Times.checkedApply(Integer n, Fn1<? super A, ? extends A> fn, A a)

static <A, B extends Comparable> BiPredicate<A,A>

CmpEqBy.cmpEqBy(Fn1<? super A, ? extends B> compareFn)

static <A, B extends Comparable> Predicate<A>

CmpEqBy.cmpEqBy(Fn1<? super A, ? extends B> compareFn, A x)

static <A, B extends Comparable> Boolean

CmpEqBy.cmpEqBy(Fn1<? super A, ? extends B> compareFn, A x, A y)

static <A, B extends Comparable> BiPredicate<A,A>

GTBy.gtBy(Fn1<? super A, ? extends B> fn)

static <A, B extends Comparable> Predicate<A>

GTBy.gtBy(Fn1<? super A, ? extends B> fn, A y)

static <A, B extends Comparable> Boolean

GTBy.gtBy(Fn1<? super A, ? extends B> fn, A y, A x)

static <A, B extends Comparable> BiPredicate<A,A>

GTEBy.gteBy(Fn1<? super A, ? extends B> fn)

static <A, B extends Comparable> Predicate<A>

GTEBy.gteBy(Fn1<? super A, ? extends B> fn, A y)

static <A, B extends Comparable> Boolean

GTEBy.gteBy(Fn1<? super A, ? extends B> fn, A y, A x)

static <A, B extends Comparable> BiPredicate<A,A>

LTBy.ltBy(Fn1<? super A, ? extends B> fn)

static <A, B extends Comparable> Predicate<A>

LTBy.ltBy(Fn1<? super A, ? extends B> fn, A y)

static <A, B extends Comparable> Boolean

LTBy.ltBy(Fn1<? super A, ? extends B> fn, A y, A x)

static <A, B extends Comparable> BiPredicate<A,A>

LTEBy.lteBy(Fn1<? super A, ? extends B> fn)

static <A, B extends Comparable> Predicate<A>

LTEBy.lteBy(Fn1<? super A, ? extends B> fn, A y)

static <A, B extends Comparable> Boolean

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)
Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn4

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

Modifier and Type

Class

Description

final class

IfThenElse<A,B>

final class

LiftA3<A, B, C, D, App extends Applicative<?,App>, AppD extends Applicative<D,App>>

Lift into and apply an Fn3 to three Applicative values, returning the result inside the same Applicative context.

final class

RateLimit<A>

Given an Fn0 of Instants (presumably backed by a clock), a limit, a Duration, and an Iterable as, return an Iterable that iterates as according to the threshold specified by the limit per duration, using the Fn0 to advance time.

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

Modifier and Type

Class

Description

final class

IfThenElse<A,B>

final class

IfThenElse<A,B>

final class

IfThenElse<A,B>

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

Modifier and Type

Method

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>> Fn1<Applicative<C,App>, AppD>

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)

Methods in com.jnape.palatable.lambda.functions.builtin.fn4 that return types with arguments of type Fn1

Modifier and Type

Method

Description

static <A,B> Fn3<Fn1<? super A, ? extends B>, Fn1<? super A, ? extends B>, A, B>

IfThenElse.ifThenElse(Fn1<? super A, ? extends Boolean> predicate)

static <A,B> 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)

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

Modifier and Type

Method

Description

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> 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)
Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn5

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

Modifier and Type

Class

Description

final class

LiftA4<A, B, C, D, E, App extends Applicative<?,App>, AppE extends Applicative<E,App>>

Lift into and apply an Fn4 to four Applicative values, returning the result inside the same Applicative context.

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

Modifier and Type

Method

Description

static <A, B, C, D, E, App extends Applicative<?,App>, AppE extends Applicative<E,App>> Fn1<Applicative<D,App>, AppE>

LiftA4.liftA4(Fn4<A,B,C,D,E> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC)
Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn6

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

Modifier and Type

Class

Description

final class

LiftA5<A, B, C, D, E, F, App extends Applicative<?,App>, AppF extends Applicative<F,App>>

Lift into and apply an Fn5 to five Applicative values, returning the result inside the same Applicative context.

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

Modifier and Type

Method

Description

static <A, B, C, D, E, F, App extends Applicative<?,App>, AppF extends Applicative<F,App>> Fn1<Applicative<E,App>, AppF>

LiftA5.liftA5(Fn5<A,B,C,D,E,F> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC, Applicative<D,App> appD)
Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn7

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

Modifier and Type

Class

Description

final class

LiftA6<A, B, C, D, E, F, G, App extends Applicative<?,App>, AppG extends Applicative<G,App>>

Lift into and apply an Fn6 to six Applicative values, returning the result inside the same Applicative context.

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

Modifier and Type

Method

Description

static <A, B, C, D, E, F, G, App extends Applicative<?,App>, AppG extends Applicative<G,App>> Fn1<Applicative<F,App>, AppG>

LiftA6.liftA6(Fn6<A,B,C,D,E,F,G> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC, Applicative<D,App> appD, Applicative<E,App> appE)
Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn8

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

Modifier and Type

Class

Description

final class

LiftA7<A, B, C, D, E, F, G, H, App extends Applicative<?,App>, AppH extends Applicative<H,App>>

Lift into and apply an Fn7 to seven Applicative values, returning the result inside the same Applicative context.

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

Modifier and Type

Method

Description

static <A, B, C, D, E, F, G, H, App extends Applicative<?,App>, AppH extends Applicative<H,App>> Fn1<Applicative<G,App>, AppH>

LiftA7.liftA7(Fn7<A,B,C,D,E,F,G,H> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC, Applicative<D,App> appD, Applicative<E,App> appE, Applicative<F,App> appF)
Uses of Fn1 in com.jnape.palatable.lambda.functions.ordering

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

Modifier and Type

Method

Description

<R> R

ComparisonRelation.Equal.match(Fn1<? super ComparisonRelation.LessThan, ? extends R> aFn, Fn1<? super ComparisonRelation.Equal, ? extends R> bFn, Fn1<? super ComparisonRelation.GreaterThan, ? extends R> cFn)

<R> R

ComparisonRelation.GreaterThan.match(Fn1<? super ComparisonRelation.LessThan, ? extends R> aFn, Fn1<? super ComparisonRelation.Equal, ? extends R> bFn, Fn1<? super ComparisonRelation.GreaterThan, ? extends R> cFn)

<R> R

ComparisonRelation.LessThan.match(Fn1<? super ComparisonRelation.LessThan, ? extends R> aFn, Fn1<? super ComparisonRelation.Equal, ? extends R> bFn, Fn1<? super ComparisonRelation.GreaterThan, ? extends R> cFn)
Uses of Fn1 in com.jnape.palatable.lambda.functions.recursion

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

Modifier and Type

Class

Description

final class

Trampoline<A,B>

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

Classes in com.jnape.palatable.lambda.functions.recursion that implement interfaces with type arguments of type Fn1

Modifier and Type

Class

Description

final class

Trampoline<A,B>

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

Methods in com.jnape.palatable.lambda.functions.recursion that return Fn1

Modifier and Type

Method

Description

static <A,B> Fn1<A,B>

Trampoline.trampoline(Fn1<? super A, ? extends RecursiveResult<A,B>> fn)

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

Modifier and Type

Method

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> 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.

<R> R

RecursiveResult.Recurse.match(Fn1<? super A, ? extends R> aFn, Fn1<? super B, ? extends R> bFn)

<R> R

RecursiveResult.Terminate.match(Fn1<? super A, ? extends R> aFn, Fn1<? super B, ? extends R> bFn)

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>> AppTrav

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.

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

Modifier and Type

Method

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.
Uses of Fn1 in com.jnape.palatable.lambda.functions.specialized

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

Modifier and Type

Interface

Description

interface

BiMonoidFactory<A,B,C>

interface

BiPredicate<A,B>

A specialized Fn2 that returns a Boolean when fully applied, or a Predicate when partially applied.

interface

BiSemigroupFactory<A,B,C>

interface

Kleisli<A, B, M extends Monad<?,M>, MB extends Monad<B,M>>

The Kleisli arrow of a Monad, manifest as simply an Fn1<A, MB>.

interface

MonoidFactory<A,B>

interface

Predicate<A>

A specialized Fn1 that returns a Boolean.

interface

SemigroupFactory<A,B>

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

Modifier and Type

Method

Description

default <Z> Fn2<Z,B,Boolean>

BiPredicate.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> Predicate<Z>

Predicate.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> 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.

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.

static <A, B, M extends Monad<?,M>, MB extends Monad<B,M>> Kleisli<A,B,M,MB>

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.

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

Modifier and Type

Method

Description

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.

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 <C> Predicate<A>

Predicate.discardR(Applicative<C,Fn1<A,?>> appB)

Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
Uses of Fn1 in com.jnape.palatable.lambda.functor

Methods in com.jnape.palatable.lambda.functor with parameters of type Fn1

Modifier and Type

Method

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 extends ContraA, D extends ContraB> BoundedBifunctor<C,D,ContraA,ContraB,BF>

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<C,B,ContraA,ContraB,BF>

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<A,C,ContraA,ContraB,BF>

BoundedBifunctor.biMapR(Fn1<? super B, ? extends C> fn)

Covariantly map the right parameter into a value that is covariant to ContraB.

default <Z> Cartesian<Z,B,P>

Cartesian.contraMap(Fn1<? super Z, ? 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.

 Contravariant<B,C>

Contravariant.contraMap(Fn1<? super B, ? 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.

<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> 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.

default <Z> Cartesian<Z,B,P>

Cartesian.diMapL(Fn1<? super Z, ? extends A> fn)

Contravariantly map over the left 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 <C> Cartesian<A,C,P>

Cartesian.diMapR(Fn1<? super B, ? extends C> fn)

Covariantly map over the right 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 Applicative<B,App>

Applicative.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 Functor<B,F>

Functor.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

Method parameters in com.jnape.palatable.lambda.functor with type arguments of type Fn1

Modifier and Type

Method

Description

default 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.

 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.
Uses of Fn1 in com.jnape.palatable.lambda.functor.builtin

Fields in com.jnape.palatable.lambda.functor.builtin declared as Fn1

Modifier and Type

Field

Description

private final Fn1<? super B, ? extends T>

Exchange.bt

private final Fn1<? super B, ? extends T>

Market.bt

private final Fn1<Object, Lazy<Object>>

Lazy.Compose.flatMap

private final Fn1<? super S, ? extends A>

Exchange.sa

private final Fn1<? super S, ? extends Either<T,A>>

Market.sta

private final Fn1<? super Monoid<W>, ? extends Tuple2<A,W>>

Writer.writerFn

Methods in com.jnape.palatable.lambda.functor.builtin that return Fn1

Modifier and Type

Method

Description

Fn1<? super B, ? extends T>

Exchange.bt()

Extract the mapping B -> T.

Fn1<? super B, ? extends T>

Market.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 -> Either<T, A>.

Methods in com.jnape.palatable.lambda.functor.builtin with parameters of type Fn1

Modifier and Type

Method

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.

<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.

<Z> Exchange<A,B,Z,T>

Exchange.contraMap(Fn1<? super Z, ? extends S> fn)

Contravariantly map A <- B.

<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,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,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> Exchange<A,B,Z,T>

Exchange.diMapL(Fn1<? super Z, ? extends S> fn)

Contravariantly map over the left 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.

<C> Exchange<A,B,S,C>

Exchange.diMapR(Fn1<? super T, ? extends C> fn)

Covariantly map over the right parameter.

 Market<A,B,S,U>

Market.diMapR(Fn1<? super T, ? extends U> fn)

Covariantly map over the right parameter.

<C> Tagged<S,C>

Tagged.diMapR(Fn1<? super B, ? extends C> fn)

Covariantly map over the right parameter.

<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.

 Identity

Identity.flatMap(Fn1<? super A, ? extends Monad<B, Identity<?>>> f)

Chain dependent computations that may continue or short-circuit based on previous results.

 Lazy

Lazy.flatMap(Fn1<? super A, ? extends Monad<B,Lazy<?>>> f)

Chain dependent computations that may continue or short-circuit based on previous results.

 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.

 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.

<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.

 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.

 Compose<F,G,B>

Compose.fmap(Fn1<? super A, ? extends B> 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.

 Identity

Identity.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

final Lazy

Lazy.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 Market<A,B,S,U>

Market.fmap(Fn1<? super T, ? extends U> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 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.

 Writer<W,B>

Writer.fmap(Fn1<? super A, ? extends B> 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.

 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.

 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.

 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)

Create a State that maps its initial state into its final state, returning a Unit result type.

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.

<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.

 Identity

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.

 Lazy

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.

 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.

 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.

<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.

 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, App extends Applicative<?,App>, TravB extends Traversable<C, Const<A,?>>, AppTrav extends Applicative<TravB,App>> AppTrav

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.

<B, App extends Applicative<?,App>, TravB extends Traversable<B, Identity<?>>, AppTrav extends Applicative<TravB,App>> AppTrav

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>> AppTrav

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>, TravC extends Traversable<C, Tagged<S,?>>, AppTrav extends Applicative<TravC,App>> AppTrav

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.

Method parameters in com.jnape.palatable.lambda.functor.builtin with type arguments of type Fn1

Modifier and Type

Method

Description

 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.

<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.

 Lazy<Identity>

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.

 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.

 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.

 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.

<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.

 Identity

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.

 Lazy

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.

 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.

 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.

<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.

 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.

Constructors in com.jnape.palatable.lambda.functor.builtin with parameters of type Fn1

Modifier

Constructor

Description

private

Compose(Lazy<Object> source, Fn1<Object, Lazy<Object>> flatMap)

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)

private

Writer(Fn1<? super Monoid<W>, ? extends Tuple2<A,W>> writerFn)
Uses of Fn1 in com.jnape.palatable.lambda.internal.iteration

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

Modifier and Type

Field

Description

private final Fn1<? super A, ? extends Iterable<RecursiveResult<A,B>>>

TrampoliningIterator.fn

private final Fn1<? super A, ? extends B>

MappingIterator.function

private final Fn1<? super B, Maybe<Tuple2<A,B>>>

UnfoldingIterator.function

private final Fn1<? super A, ? extends Boolean>

FilteringIterator.predicate

private final Fn1<? super A, ? extends Boolean>

PredicatedTakingIterator.predicate

Fields in com.jnape.palatable.lambda.internal.iteration with type parameters of type Fn1

Modifier and Type

Field

Description

private final List<Fn1<?,?>>

MappingIterable.mappers

private final List<Fn1<? super A, ? extends Boolean>>

FilteringIterable.predicates

private final ImmutableQueue<Fn1<? super A, ? extends Boolean>>

PredicatedDroppingIterable.predicates

private final Iterator<Fn1<? super A, ? extends Boolean>>

PredicatedDroppingIterator.predicates

private final List<Fn1<? super A, ? extends Boolean>>

PredicatedTakingIterable.predicates

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

Modifier

Constructor

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)

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)

Constructor parameters in com.jnape.palatable.lambda.internal.iteration with type arguments of type Fn1

Modifier

Constructor

Description

PredicatedDroppingIterator(ImmutableQueue<Fn1<? super A, ? extends Boolean>> predicates, Iterator<A> asIterator)
Uses of Fn1 in com.jnape.palatable.lambda.io

Fields in com.jnape.palatable.lambda.io with type parameters of type Fn1

Modifier and Type

Field

Description

private final Choice2<IO<?>, Fn1<Object,IO<?>>>

IO.Compose.composition

Methods in com.jnape.palatable.lambda.io with parameters of type Fn1

Modifier and Type

Method

Description

final IO<A>

IO.catchError(Fn1<? super Throwable, ? extends Monad<A,IO<?>>> recoveryFn)

Catch any thrown errors inside the Monad and resume normal operations.

final IO<A>

IO.exceptionally(Fn1<? super Throwable, ? extends A> recoveryFn)

Deprecated.
in favor of canonical IO.catchError(Fn1)

final IO

IO.flatMap(Fn1<? super A, ? extends Monad<B,IO<?>>> f)

Chain dependent computations that may continue or short-circuit based on previous results.

final IO

IO.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 IO

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.

Method parameters in com.jnape.palatable.lambda.io with type arguments of type Fn1

Modifier and Type

Method

Description

final Lazy<IO>

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.

final IO

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.

Constructor parameters in com.jnape.palatable.lambda.io with type arguments of type Fn1

Modifier

Constructor

Description

private

Compose(IO<?> source, Choice2<IO<?>, Fn1<Object,IO<?>>> composition)
Uses of Fn1 in com.jnape.palatable.lambda.monad

Fields in com.jnape.palatable.lambda.monad declared as Fn1

Modifier and Type

Field

Description

private final Fn1<A, SafeT.Body<M,B>>

SafeT.Body.Suspended.f

Methods in com.jnape.palatable.lambda.monad that return Fn1

Modifier and Type

Method

Description

private <Z> Fn1<SafeT.Body.Suspended<M,?,Z>, RecursiveResult<SafeT.Body<M,B>, Either<MonadRec<SafeT.Body<M,B>, M>, B>>>

SafeT.Body.Suspended.associateRight(Fn1<Z, SafeT.Body<M,B>> f)

Methods in com.jnape.palatable.lambda.monad with parameters of type Fn1

Modifier and Type

Method

Description

<A> R

SafeT.Body.Suspended.Φ.apply(SafeT.Body<M,A> source, Fn1<A, SafeT.Body<M,B>> fn)

private <Z> Fn1<SafeT.Body.Suspended<M,?,Z>, RecursiveResult<SafeT.Body<M,B>, Either<MonadRec<SafeT.Body<M,B>, M>, B>>>

SafeT.Body.Suspended.associateRight(Fn1<Z, SafeT.Body<M,B>> f)

MonadError<E,A,M>

MonadError.catchError(Fn1<? super E, ? extends Monad<A,M>> recoveryFn)

Catch any thrown errors inside the Monad and resume normal operations.

MonadWriter<W,A,MW>

MonadWriter.censor(Fn1<? super W, ? extends W> fn)

Update the accumulated state.

 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.

 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.

 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.

 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.

 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.

 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 Monad<B,M>

Monad.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

default MonadError<E,B,M>

MonadError.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

default MonadReader<R,B,MR>

MonadReader.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

default MonadRec<B,M>

MonadRec.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

default MonadWriter<W,B,MW>

MonadWriter.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 SafeT<M,B>

SafeT.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 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.

<R> R

SafeT.Body.Done.match(Fn1<? super Either<MonadRec<SafeT.Body<M,A>, M>, A>, ? extends R> aFn, Fn1<? super SafeT.Body.Suspended<M,?,A>, ? extends R> bFn)

<R> R

SafeT.Body.More.match(Fn1<? super Either<MonadRec<SafeT.Body<M,A>, M>, A>, ? extends R> aFn, Fn1<? super SafeT.Body.Suspended<M,?,A>, ? extends R> bFn)

<R> R

SafeT.Body.Suspended.match(Fn1<? super Either<MonadRec<SafeT.Body<M,B>, M>, B>, ? extends R> aFn, Fn1<? super SafeT.Body.Suspended<M,?,B>, ? extends R> bFn)

private static <M extends MonadRec<?,M>, A, B> SafeT.Body<M,B>

SafeT.Body.suspend(SafeT.Body<M,A> freeA, Fn1<A, SafeT.Body<M,B>> fn)

 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.

 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.

Method parameters in com.jnape.palatable.lambda.monad with type arguments of type Fn1

Modifier and Type

Method

Description

default 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 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 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 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 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.

 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 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 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 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 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 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.

 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.

Constructors in com.jnape.palatable.lambda.monad with parameters of type Fn1

Modifier

Constructor

Description

private

Suspended(SafeT.Body<M,A> source, Fn1<A, SafeT.Body<M,B>> f)
Uses of Fn1 in com.jnape.palatable.lambda.monad.transformer

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

Modifier and Type

Method

Description

 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 MonadT<M,B,MT,T>

MonadT.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

Method parameters in com.jnape.palatable.lambda.monad.transformer with type arguments of type Fn1

Modifier and Type

Method

Description

default 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 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.
Uses of Fn1 in com.jnape.palatable.lambda.monad.transformer.builtin

Fields in com.jnape.palatable.lambda.monad.transformer.builtin declared as Fn1

Modifier and Type

Field

Description

private final Fn1<? super R, ? extends MonadRec<A,M>>

ReaderT.f

private final Fn1<? super S, ? extends MonadRec<Tuple2<A,S>, M>>

StateT.stateFn

private final Fn1<? super Monoid<W>, ? extends MonadRec<Tuple2<A,W>, M>>

WriterT.writerFn

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

Modifier and Type

Method

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> 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.

EitherT<M,L,R>

EitherT.catchError(Fn1<? super L, ? extends Monad<R, EitherT<M,L,?>>> recoveryFn)

Catch any thrown errors inside the Monad and resume normal operations.

MaybeT<M,A>

MaybeT.catchError(Fn1<? super Unit, ? extends Monad<A, MaybeT<M,?>>> recoveryFn)

Catch any thrown errors inside the Monad and resume normal operations.

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> ReaderT<Q,M,A>

ReaderT.diMapL(Fn1<? super Q, ? extends R> fn)

Contravariantly map over the left parameter.

 ReaderT<R,M,B>

ReaderT.diMapR(Fn1<? super A, ? extends B> fn)

Covariantly map over the right parameter.

MaybeT<M,A>

MaybeT.filter(Fn1<? super A, ? extends Boolean> predicate)

If the embedded value is present and satisfies predicate then return just the embedded value

<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.

 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.

 IterateT<M,B>

IterateT.flatMap(Fn1<? super A, ? extends Monad<B, IterateT<M,?>>> f)

Chain dependent computations that may continue or short-circuit based on previous results.

 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.

 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.

 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.

 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.

 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.fmap(Fn1<? super R, ? extends R2> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 IdentityT<M,B>

IdentityT.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 IterateT<M,B>

IterateT.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 LazyT<M,B>

LazyT.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 MaybeT<M,B>

MaybeT.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 ReaderT<R,M,B>

ReaderT.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 StateT<S,M,B>

StateT.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 WriterT<W,M,B>

WriterT.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

<MU extends MonadRec<Unit,M>> MU

IterateT.forEach(Fn1<? super A, ? extends MonadRec<Unit,M>> fn)

Convenience method for folding the spine of this IterateT with an action to perform on each element without accumulating any results.

static <S, M extends MonadRec<?,M>, A> StateT<S,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.

 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.

 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<R,N,B>

ReaderT.mapReaderT(Fn1<? super MA, ? extends MonadRec<B,N>> fn)

Map the current monadic embedding to a new one in a potentially different Monad.

<N extends MonadRec<?,N>, B> StateT<S,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<S,M,Unit>

StateT.modify(Fn1<? super S, ? extends MonadRec<S,M>> updateFn)

Lift a function that makes a stateful modification inside an Monad into StateT.

static <R, M extends MonadRec<?,M>, A> ReaderT<R,M,A>

ReaderT.readerT(Fn1<? super R, ? extends MonadRec<A,M>> fn)

Lift a function (R -> Monad<A, M>) into a ReaderT instance.

static <S, M extends MonadRec<?,M>, A> StateT<S,M,A>

StateT.stateT(Fn1<? super S, ? extends MonadRec<Tuple2<A,S>, M>> stateFn)

Lift a state-sensitive monadically embedded computation into StateT.

<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.

 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.

 IterateT<M,B>

IterateT.trampolineM(Fn1<? super A, ? extends MonadRec<RecursiveResult<A,B>, IterateT<M,?>>> fn)

Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.

 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.

 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.

 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.

 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.

 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.

static <M extends MonadRec<?,M>, A, B> IterateT<M,A>

IterateT.unfold(Fn1<? super B, ? extends MonadRec<Maybe<Tuple2<A,B>>, M>> fn, MonadRec<B,M> mb)

Lazily unfold an IterateT from an unfolding function fn and a starting seed value mb by successively applying fn to the latest seed value, producing maybe a value to yield out and the next seed value for the subsequent computation.

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.

Method parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type Fn1

Modifier and Type

Method

Description

<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.

 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.

 Lazy<IterateT<M,B>>

IterateT.lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, IterateT<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.

 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.

 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.

 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.

 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.

 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> 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.

 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.

 IterateT<M,B>

IterateT.zip(Applicative<Fn1<? super A, ? extends B>, IterateT<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.

 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.

 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.

 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.

 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.

 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.

Constructors in com.jnape.palatable.lambda.monad.transformer.builtin with parameters of type Fn1

Modifier

Constructor

Description

private

ReaderT(Fn1<? super R, ? extends MonadRec<A,M>> f)

private

StateT(Fn1<? super S, ? extends MonadRec<Tuple2<A,S>, M>> stateFn)

private

WriterT(Pure<M> pureM, Fn1<? super Monoid<W>, ? extends MonadRec<Tuple2<A,W>, M>> writerFn)
Uses of Fn1 in com.jnape.palatable.lambda.monoid

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

Modifier and Type

Interface

Description

interface

Monoid<A>

A Monoid is the pairing of a Semigroup with an identity element.

Methods in com.jnape.palatable.lambda.monoid with parameters of type Fn1

Modifier and Type

Method

Description

default A

Monoid.foldMap(Fn1<? super B, ? extends A> fn, Iterable bs)

Homomorphism combined with catamorphism.
Uses of Fn1 in com.jnape.palatable.lambda.monoid.builtin

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

Modifier and Type

Class

Description

final class

AddAll<A, C extends Collection<A>>

The Monoid instance formed under mutative concatenation for an arbitrary Collection.

final class

And

A Monoid instance formed by Boolean.

final class

Collapse<_1,_2>

A Monoid instance formed by a Tuple2<_1, _2> and monoids over _1 and _2.

final class

Compose<A>

A Monoid instance formed by CompletableFuture<A> and a monoid over A.

final class

Concat<A>

The Monoid instance formed under concatenation for an arbitrary Iterable.

final class

Endo<A>

A Monoid formed by Fn1 under composition.

final class

EndoK<M extends MonadRec<?,M>, A, MA extends MonadRec<A,M>>

The monoid formed under monadic endomorphism.

final class

First<A>

A Monoid instance formed by Maybe<A>.

final class

Join

A Monoid instance formed by String that concats two strings together.

final class

Last<A>

A Monoid instance formed by Maybe<A>.

final class

LeftAll<L,R>

A Monoid instance formed by Either<L,R> and a monoid over L.

final class

LeftAny<L,R>

A Monoid instance formed by Either<L,R> and a monoid over L.

final class

Merge<L,R>

A Monoid instance formed by Either.merge(Fn2, Fn2, Either...), a semigroup over L, and a monoid over R.

final class

MergeHMaps

A Monoid instance formed by merging HMaps using the chosen TypeSafeKey -> Semigroup mappings, defaulting to Last in case no Semigroup has been chosen for a given TypeSafeKey.

final class

MergeMaps<K,V>

A Monoid instance formed by Map.merge(Object, Object, BiFunction) and a semigroup over V.

final class

Or

A Monoid instance formed by Boolean.

final class

Present<A>

A Monoid instance formed by Maybe<A> and a semigroup over A.

final class

PutAll

A Monoid instance formed by HMap that simply combines all the mappings.

final class

RightAll<L,R>

A Monoid instance formed by Either<L,R> and a monoid over R.

final class

RightAny<L,R>

A Monoid instance formed by Either<L,R> and a monoid over R.

final class

RunAll<A>

Run IO operations, aggregating their results in terms of the provided Monoid.

final class

Trivial

The trivial Unit Monoid formed under constantly.

final class

Union<A>

Given two Iterables xs and ys, return the concatenation of the distinct elements of both xs and ys.

final class

Xor

Logical exclusive-or.

Classes in com.jnape.palatable.lambda.monoid.builtin that implement interfaces with type arguments of type Fn1

Modifier and Type

Class

Description

final class

Endo<A>

A Monoid formed by Fn1 under composition.

final class

EndoK<M extends MonadRec<?,M>, A, MA extends MonadRec<A,M>>

The monoid formed under monadic endomorphism.

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

Modifier and Type

Method

Description

static <A, C extends Collection<A>> Fn1<C,C>

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)

Methods in com.jnape.palatable.lambda.monoid.builtin that return types with arguments of type Fn1

Modifier and Type

Method

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>> Monoid<Fn1<A,MA>>

EndoK.endoK(Pure<M> pureM)

Methods in com.jnape.palatable.lambda.monoid.builtin with parameters of type Fn1

Modifier and Type

Method

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)

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> A

Endo.endo(Fn1<A,A> f, Fn1<A,A> g, A a)

 Boolean

And.foldMap(Fn1<? super B, ? extends Boolean> fn, Iterable bs)

 Iterable<A>

Concat.foldMap(Fn1<? super B, ? extends Iterable<A>> fn, Iterable bs)

 Maybe<A>

First.foldMap(Fn1<? super B, ? extends Maybe<A>> fn, Iterable bs)

 HMap

MergeHMaps.foldMap(Fn1<? super B, ? extends HMap> fn, Iterable bs)

 Boolean

Or.foldMap(Fn1<? super B, ? extends Boolean> fn, Iterable bs)
Uses of Fn1 in com.jnape.palatable.lambda.optics

Methods in com.jnape.palatable.lambda.optics that return Fn1

Modifier and Type

Method

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>> Fn1<PAFB,PSFT>

Optic.monomorphize()

Produce a monomorphic Fn1 backed by this Optic.

Methods in com.jnape.palatable.lambda.optics that return types with arguments of type Fn1

Modifier and Type

Method

Description

default Tuple2<Fn1<? super S, ? extends A>, Fn1<? super B, ? extends T>>

Iso.unIso()

Destructure this Iso into the two functions S -< A and B -< T that constitute the isomorphism.

default Tuple2<Fn1<? super S, ? extends A>, Fn1<? super B, ? extends T>>

Iso.unIso()

Destructure this Iso into the two functions S -< A and B -< T that constitute the isomorphism.

default Tuple2<Fn1<? super B, ? extends T>, Fn1<? super S, ? extends Either<T,A>>>

Prism.unPrism()

Recover the two mappings encapsulated by this Prism by sending it through a Market.

default Tuple2<Fn1<? super B, ? extends T>, Fn1<? super S, ? extends Either<T,A>>>

Prism.unPrism()

Recover the two mappings encapsulated by this Prism by sending it through a Market.

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

Modifier and Type

Method

Description

default <R> Iso<R,T,A,B>

Iso.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> Prism<R,T,A,B>

Prism.contraMap(Fn1<? super R, ? extends S> fn)

Contravariantly map A <- B.

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> 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> 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> Iso<R,T,A,B>

Iso.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> Prism<R,T,A,B>

Prism.diMapL(Fn1<? super R, ? extends S> fn)

Contravariantly map over the left parameter.

default Iso<S,U,A,B>

Iso.diMapR(Fn1<? super T, ? extends U> fn)

Covariantly map over the right parameter.

default Lens<S,U,A,B>

Lens.diMapR(Fn1<? super T, ? extends U> fn)

Covariantly map over the right parameter.

default Prism<S,U,A,B>

Prism.diMapR(Fn1<? super T, ? extends U> fn)

Covariantly map over the right parameter.

default 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 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 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 Iso<S,U,A,B>

Iso.fmap(Fn1<? super T, ? extends U> fn)

Covariantly transmute this functor's parameter using the given mapping function.

default 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 Prism<S,U,A,B>

Prism.fmap(Fn1<? super T, ? extends U> fn)

Covariantly transmute this functor's parameter using the given mapping function.

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> 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,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> Iso<S,T,C,B>

Iso.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> 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> Prism<S,T,C,B>

Prism.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 <Z> Iso<S,T,A,Z>

Iso.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> 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> Prism<S,T,A,Z>

Prism.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 <R> Iso<R,T,A,B>

Iso.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> 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> Prism<R,T,A,B>

Prism.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 Iso<S,U,A,B>

Iso.mapT(Fn1<? super T, ? extends U> fn)

Covariantly map T to U, yielding a new optic.

default Lens<S,U,A,B>

Lens.mapT(Fn1<? super T, ? extends U> fn)

Covariantly map T to U, yielding a new optic.

default 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 Prism<S,U,A,B>

Prism.mapT(Fn1<? super T, ? extends U> fn)

Covariantly map T to U, yielding a new optic.

default ProtoOptic<P,S,U,A,B>

ProtoOptic.mapT(Fn1<? super T, ? extends U> fn)

Covariantly map T to U, yielding a new optic.

static , 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<P,F,S,T,A,B>

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 factory method for creating a Prism given a mapping from S -> Either<T, A> and a mapping from B -> T.

static <S,A,B> Pure<Iso<S,?,A,B>>

Iso.pureIso(Fn1<? super S, ? extends A> sa)

The canonical Pure instance for Iso.

static <S,A,B> Pure<Lens<S,?,A,B>>

Lens.pureLens(Fn1<? super S, ? extends A> sa)

The canonical Pure instance for Lens.

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.

default 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 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 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.

Method parameters in com.jnape.palatable.lambda.optics with type arguments of type Fn1

Modifier and Type

Method

Description

default 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 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 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 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.
Uses of Fn1 in com.jnape.palatable.lambda.optics.functions

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

Modifier and Type

Class

Description

final class

Matching<S,T,A,B>

final class

Over<S,T,A,B>

Given an Optic, a function from A to B, and a "larger" value S, produce a T by retrieving the A from the S, applying the function, and updating the S with the B resulting from the function.

final class

Pre, S, T, A, B>

Turn an Optic with a unary mapping that can be used for viewing some number of values into an Optic that views the first value, if it exists.

final class

Re<S,T,A,B>

Turn an Optic with a unary mapping that can be used for setting (e.g.

final class

Set<S,T,A,B>

Given an Optic, a "smaller" value B, and a "larger" value S, produce a T by lifting the Optic into the Identity functor.

final class

Under<S,T,A,B>

The inverse of Over: given an Iso, a function from T to S, and a "smaller" value B, return a "smaller" value A by traversing around the type ring (B -> T -> S -> A).

final class

View<S,T,A,B>

Given an Optic and a "larger" value S, retrieve a "smaller" value A by lifting the Optic into the Const functor.

Classes in com.jnape.palatable.lambda.optics.functions that implement interfaces with type arguments of type Fn1

Modifier and Type

Class

Description

final class

Over<S,T,A,B>

Given an Optic, a function from A to B, and a "larger" value S, produce a T by retrieving the A from the S, applying the function, and updating the S with the B resulting from the function.

final class

Over<S,T,A,B>

Given an Optic, a function from A to B, and a "larger" value S, produce a T by retrieving the A from the S, applying the function, and updating the S with the B resulting from the function.

final class

Set<S,T,A,B>

Given an Optic, a "smaller" value B, and a "larger" value S, produce a T by lifting the Optic into the Identity functor.

final class

Under<S,T,A,B>

The inverse of Over: given an Iso, a function from T to S, and a "smaller" value B, return a "smaller" value A by traversing around the type ring (B -> T -> S -> A).

final class

View<S,T,A,B>

Given an Optic and a "larger" value S, retrieve a "smaller" value A by lifting the Optic into the Const functor.

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

Modifier and Type

Method

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)

Methods in com.jnape.palatable.lambda.optics.functions that return types with arguments of type Fn1

Modifier and Type

Method

Description

static <S,T,A,B> Fn2<Fn1<? super A, ? extends B>, S, T>

Over.over(Optic<? super Fn1<?,?>, ? super Identity<?>, S, T, A, B> optic)

static <S,T,A,B> Fn2<Fn1<? super T, ? extends S>, B, A>

Under.under(Optic<? super Exchange<A,B,?,?>, ? super Identity<?>, S, T, A, B> optic)

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

Modifier and Type

Method

Description

T

Over.checkedApply(Optic<? super Fn1<?,?>, ? super Identity<?>, S, T, A, B> optic, Fn1<? super A, ? extends B> fn, S s)

A

Under.checkedApply(Optic<? super Exchange<A,B,?,?>, ? super Identity<?>, S, T, A, B> optic, Fn1<? super T, ? extends S> fn, B b)

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)

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

Modifier and Type

Method

Description

T

Over.checkedApply(Optic<? super Fn1<?,?>, ? super Identity<?>, S, T, A, B> optic, Fn1<? super A, ? extends B> fn, S s)

T

Set.checkedApply(Optic<? super Fn1<?,?>, ? super Identity<?>, S, T, A, B> optic, B b, S s)

A

View.checkedApply(Optic<? super Fn1<?,?>, ? super Const<A,?>, S, T, A, B> optic, 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)
Uses of Fn1 in com.jnape.palatable.lambda.optics.lenses

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

Modifier and Type

Method

Description

static <X, CX extends Collection<X>> Lens.Simple<CX,CX>

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> Lens<Map<K,V>,M,M,M>

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>> Lens.Simple<CX,Set<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>> Lens.Simple<CX, Stream<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>> Lens.Simple<SetA,Boolean>

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> Lens<Map<K,V>,M,Maybe<V>,Maybe<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.
Uses of Fn1 in com.jnape.palatable.lambda.optics.prisms

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

Modifier and Type

Method

Description

static <M extends Map<K,V>, K, V> Prism<Map<K,V>,M,V,V>

MapPrism.valueAt(Fn1<Map<K,V>,M> copyFn, K k)

A Prism that focuses on the value at a key in a Map, and produces an instance of M on the way back out.
Uses of Fn1 in com.jnape.palatable.lambda.semigroup

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

Modifier and Type

Interface

Description

interface

Semigroup<A>

A Semigroup is a closed, associative category.
Uses of Fn1 in com.jnape.palatable.lambda.semigroup.builtin

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

Modifier and Type

Class

Description

final class

Absent<A>

A Semigroup instance formed by Maybe<A> and a semigroup over A.

final class

Collapse<_1,_2>

A Semigroup instance formed by a Tuple2<_1, _2> and semigroups over _1 and _2.

final class

Compose<A>

A Semigroup instance formed by CompletableFuture<A> and a semigroup over A.

final class

Intersection<A>

Given two Iterables xs and ys, return the distinct elements of xs that are also in ys in order of their unique occurrence in xs.

final class

LeftAll<L,R>

A Semigroup instance formed by Either<L,R> and a semigroup over L.

final class

LeftAny<L,R>

A Semigroup instance formed by Either<L,R> and a semigroup over L.

final class

Max<A extends Comparable<A>>

A Semigroup over A that chooses between two values x and y via the following rules: If x is strictly less than y, return y Otherwise, return x

final class

MaxBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B, produce a Semigroup over A that chooses between two values x and y via the following rules: If x is strictly less than y in terms of B, return y Otherwise, return x

final class

MaxWith<A>

Given a comparator for some type A, produce a Semigroup over A that chooses between two values x and y via the following rules: If x is strictly less than y in terms of B, return y Otherwise, return x

final class

Merge<L,R>

A Semigroup instance formed by Either.merge(Fn2, Fn2, Either...) and semigroups over L and R.

final class

Min<A extends Comparable<A>>

A Semigroup over A that chooses between two values x and y via the following rules: If x is strictly greater than y, return y Otherwise, return x

final class

MinBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B, produce a Semigroup over A that chooses between two values x and y via the following rules: If x is strictly greater than y in terms of B, return y Otherwise, return x

final class

MinWith<A>

Given a comparator for some type A, produce a Semigroup over A that chooses between two values x and y via the following rules: If x is strictly greater than y in terms of B, return y Otherwise, return x

final class

RightAll<L,R>

A Semigroup instance formed by Either<L,R> and a semigroup over R.

final class

RightAny<L,R>

A Semigroup instance formed by Either<L,R> and a semigroup over R.

final class

RunAll<A>

Run IO operations, aggregating their results in terms of the provided Semigroup.

Classes in com.jnape.palatable.lambda.semigroup.builtin that implement interfaces with type arguments of type Fn1

Modifier and Type

Class

Description

final class

MaxBy<A, B extends Comparable>

Given a mapping function from some type A to some Comparable type B, produce a Semigroup over A that chooses between two values x and y via the following rules: If x is strictly less than y in terms of B, return y Otherwise, return x

final class

MinBy<A, B extends Comparable>

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

Methods in com.jnape.palatable.lambda.semigroup.builtin that return Fn1

Modifier and Type

Method

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>> Fn1<A,A>

Max.max(A x)

static <A, B extends Comparable> Fn1<A,A>

MaxBy.maxBy(Fn1<? super A, ? extends B> compareFn, A x)

static <A> Fn1<A,A>

MaxWith.maxWith(Comparator<A> 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>> Fn1<A,A>

Min.min(A x)

static <A, B extends Comparable> Fn1<A,A>

MinBy.minBy(Fn1<? super A, ? extends B> compareFn, A x)

static <A> Fn1<A,A>

MinWith.minWith(Comparator<A> 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)

Methods in com.jnape.palatable.lambda.semigroup.builtin with parameters of type Fn1

Modifier and Type

Method

Description

Semigroup<A>

MaxBy.checkedApply(Fn1<? super A, ? extends B> compareFn)

Semigroup<A>

MinBy.checkedApply(Fn1<? super A, ? extends B> compareFn)

static <A, B extends Comparable> Semigroup<A>

MaxBy.maxBy(Fn1<? super A, ? extends B> compareFn)

static <A, B extends Comparable> Fn1<A,A>

MaxBy.maxBy(Fn1<? super A, ? extends B> compareFn, A x)

static <A, B extends Comparable> A

MaxBy.maxBy(Fn1<? super A, ? extends B> compareFn, A x, A y)

static <A, B extends Comparable> Semigroup<A>

MinBy.minBy(Fn1<? super A, ? extends B> compareFn)

static <A, B extends Comparable> Fn1<A,A>

MinBy.minBy(Fn1<? super A, ? extends B> compareFn, A x)

static <A, B extends Comparable> A

MinBy.minBy(Fn1<? super A, ? extends B> compareFn, A x, A y)
Uses of Fn1 in com.jnape.palatable.lambda.traversable

Methods in com.jnape.palatable.lambda.traversable with parameters of type Fn1

Modifier and Type

Method

Description

 LambdaIterable

LambdaIterable.flatMap(Fn1<? super A, ? extends Monad<B, LambdaIterable<?>>> f)

Chain dependent computations that may continue or short-circuit based on previous results.

 LambdaIterable

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)

default Traversable<B,T>

Traversable.fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 LambdaIterable

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>> AppTrav

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.

<C, App extends Applicative<?,App>, TravC extends Traversable<C, LambdaMap<A,?>>, AppTrav extends Applicative<TravC,App>> AppTrav

LambdaMap.traverse(Fn1<? super B, ? extends Applicative<C,App>> fn, Fn1<? super TravC, ? extends AppTrav> pure)

<B, App extends Applicative<?,App>, TravB extends Traversable<B,T>, AppTrav extends Applicative<TravB,App>> AppTrav

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.

Method parameters in com.jnape.palatable.lambda.traversable with type arguments of type Fn1

Modifier and Type

Method

Description

 Lazy<LambdaIterable>

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.

 LambdaIterable

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.

Uses of Interfacecom.jnape.palatable.lambda.functions.Fn1

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

Uses of Fn1 in com.jnape.palatable.lambda.adt.choice

Uses of Fn1 in com.jnape.palatable.lambda.adt.coproduct

Uses of Fn1 in com.jnape.palatable.lambda.adt.hlist

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

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

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

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

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

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

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

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

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

Uses of Fn1 in com.jnape.palatable.lambda.functions.ordering

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

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

Uses of Fn1 in com.jnape.palatable.lambda.functor

Uses of Fn1 in com.jnape.palatable.lambda.functor.builtin

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

Uses of Fn1 in com.jnape.palatable.lambda.io

Uses of Fn1 in com.jnape.palatable.lambda.monad

Uses of Fn1 in com.jnape.palatable.lambda.monad.transformer

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

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

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

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

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

Uses of Fn1 in com.jnape.palatable.lambda.optics.lenses

Uses of Fn1 in com.jnape.palatable.lambda.optics.prisms

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

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

Uses of Fn1 in com.jnape.palatable.lambda.traversable

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