Uses of Class
com.jnape.palatable.lambda.adt.Either

Packages that use Either

Package	Description
com.jnape.palatable.lambda.adt
com.jnape.palatable.lambda.functions.builtin.fn1
com.jnape.palatable.lambda.functor.builtin
com.jnape.palatable.lambda.io
com.jnape.palatable.lambda.monad
com.jnape.palatable.lambda.monad.transformer.builtin
com.jnape.palatable.lambda.monoid.builtin
com.jnape.palatable.lambda.optics
com.jnape.palatable.lambda.optics.functions
com.jnape.palatable.lambda.optics.lenses
com.jnape.palatable.lambda.optics.prisms
com.jnape.palatable.lambda.semigroup.builtin

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

Subclasses of Either in com.jnape.palatable.lambda.adt

Modifier and Type	Class	Description
private static final class	Either.Left<L,R>
private static final class	Either.Right<L,R>

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

Modifier and Type	Method	Description
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.

Methods in com.jnape.palatable.lambda.adt that return Either

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 <L2> Either<L2,R>	Either.biMapL(Fn1<? super L,? extends L2> 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.
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.
final <R2> Either<L,R2>	Either.discardL(Applicative<R2,Either<L,?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
final <R2> Either<L,R>	Either.discardR(Applicative<R2,Either<L,?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
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.
<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 <R2> Either<L,R2>	Either.fmap(Fn1<? super R,? extends R2> fn)	Covariantly transmute this functor's parameter using the given mapping function.
static <L, R> Either<L,R>	Either.fromMaybe(Maybe<R> maybe, Fn0<L> leftFn0)	Convert a Maybe<R> into an Either<L, R>, supplying the left value from leftFn in the case of Maybe.nothing().
final Either<R,L>	Either.invert()
static <L, R> Either<L,R>	Either.left(L l)	Static factory method for creating a left value.
final Either<L,R>	Either.merge(Fn2<? super L,? super L,? extends L> leftFn, Fn2<? super R,? super R,? extends R> rightFn, Either<L,R>... others)	Given two binary operators over L and R, merge multiple Either<L, R>s into a single Either<L, R>.
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 <R2> Either<L,R2>	Either.pure(R2 r2)	Lift the value b into this applicative functor.
static <L, R> Either<L,R>	Either.right(R r)	Static factory method for creating a right value.
Either<L,R>	Either.throwError(L l)	Throw an error value of type E into the monad.
final <L> Either<L,A>	Maybe.toEither(Fn0<L> lFn0)	If this value is absent, return the value supplied by lSupplier wrapped in Either.left.
final Either<Throwable,A>	Try.toEither()	If this is a success, wrap the value in a right(R) and return it.
final <L> Either<L,A>	Try.toEither(Fn1<? super Throwable,? extends L> fn)	If this is a success, wrap the value in a right(R) and return it.
<B> Either<L,B>	Either.trampolineM(Fn1<? super R,? extends MonadRec<RecursiveResult<R,B>,Either<L,?>>> fn)	Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
static <R> Either<Throwable,R>	Either.trying(Fn0<? extends R> fn0)	Attempt to execute the Fn0, returning its result in a right value.
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 Either<Throwable,Unit>	Either.trying(SideEffect sideEffect)	Attempt to execute the SideEffect, returning Unit 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.
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.

Methods in com.jnape.palatable.lambda.adt that return types with arguments of type Either

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.
static <L> Pure<Either<L,?>>	Either.pureEither()	The canonical Pure instance for Either.

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

Modifier and Type	Method	Description
static <A> Maybe<A>	Maybe.fromEither(Either<?,A> either)	Convenience static factory method for creating a Maybe from an Either.
final Either<L,R>	Either.merge(Fn2<? super L,? super L,? extends L> leftFn, Fn2<? super R,? super R,? extends R> rightFn, Either<L,R>... others)	Given two binary operators over L and R, merge multiple Either<L, R>s into a single Either<L, R>.

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

Modifier and Type	Method	Description
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.
final <R2> Either<L,R2>	Either.discardL(Applicative<R2,Either<L,?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
final <R2> Either<L,R>	Either.discardR(Applicative<R2,Either<L,?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
<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>.
<R2> Lazy<Either<L,R2>>	Either.lazyZip(Lazy<? extends Applicative<Fn1<? super R,? extends R2>,Either<L,?>>> lazyAppFn)	Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
<B> 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.
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.

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

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

Modifier and Type	Method	Description
Either<Iterable<L>,Iterable<R>>	Coalesce.checkedApply(Iterable<Either<L,R>> eithers)
static <A, B> Either<Iterable<A>,Iterable<B>>	Coalesce.coalesce(Iterable<Either<A,B>> eithers)

Method parameters in com.jnape.palatable.lambda.functions.builtin.fn1 with type arguments of type Either

Modifier and Type	Method	Description
Either<Iterable<L>,Iterable<R>>	Coalesce.checkedApply(Iterable<Either<L,R>> eithers)
static <A, B> Either<Iterable<A>,Iterable<B>>	Coalesce.coalesce(Iterable<Either<A,B>> eithers)

Uses of Either in com.jnape.palatable.lambda.functor.builtin

Fields in com.jnape.palatable.lambda.functor.builtin with type parameters of type Either

Modifier and Type	Field	Description
private final Fn1<? super S,? extends Either<T,A>>	Market.sta

Methods in com.jnape.palatable.lambda.functor.builtin that return types with arguments of type Either

Modifier and Type	Method	Description
Fn1<? super S,? extends Either<T,A>>	Market.sta()	Extract the mapping S -> Either<T, A>.

Uses of Either in com.jnape.palatable.lambda.io

Methods in com.jnape.palatable.lambda.io that return types with arguments of type Either

Modifier and Type	Method	Description
final IO<Either<Throwable,A>>	IO.safe()	Return a safe IO that will never throw by lifting the result of this IO into Either, catching any Throwable and wrapping it in a left.

Uses of Either in com.jnape.palatable.lambda.monad

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

Modifier and Type	Method	Description
Either<MonadRec<SafeT.Body<M,A>,M>,A>	SafeT.Body.Done.resume()
Either<MonadRec<SafeT.Body<M,A>,M>,A>	SafeT.Body.More.resume()
abstract Either<MonadRec<SafeT.Body<M,A>,M>,A>	SafeT.Body.resume()
Either<MonadRec<SafeT.Body<M,B>,M>,B>	SafeT.Body.Suspended.resume()

Methods in com.jnape.palatable.lambda.monad that return types with arguments of type Either

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)

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

Modifier and Type	Method	Description
<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)

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

Fields in com.jnape.palatable.lambda.monad.transformer.builtin with type parameters of type Either

Modifier and Type	Field	Description
private final MonadRec<Either<L,R>,M>	EitherT.melr

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

Modifier and Type	Method	Description
<MELR extends MonadRec<Either<L, R>, M>> MELR	EitherT.runEitherT()	Recover the full structure of the embedded Monad.

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

Modifier and Type	Method	Description
static <M extends MonadRec<?, M>, L, R> EitherT<M,L,R>	EitherT.eitherT(MonadRec<Either<L,R>,M> melr)	Static factory method for lifting a Monad<Either<L, R>, M> into an EitherT.

Constructor parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type Either

Modifier	Constructor	Description
private	EitherT(MonadRec<Either<L,R>,M> melr)

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

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

Modifier and Type	Method	Description
static <L, R> Either<L,R>	LeftAll.leftAll(Monoid<L> lMonoid, Either<L,R> x, Either<L,R> y)
static <L, R> Either<L,R>	LeftAny.leftAny(Monoid<L> lMonoid, Either<L,R> x, Either<L,R> y)
static <L, R> Either<L,R>	Merge.merge(Semigroup<L> lSemigroup, Monoid<R> rMonoid, Either<L,R> x, Either<L,R> y)
static <L, R> Either<L,R>	RightAll.rightAll(Monoid<R> rMonoid, Either<L,R> x, Either<L,R> y)
static <L, R> Either<L,R>	RightAny.rightAny(Monoid<R> rMonoid, Either<L,R> x, Either<L,R> y)

Methods in com.jnape.palatable.lambda.monoid.builtin that return types with arguments of type Either

Modifier and Type	Method	Description
Monoid<Either<L,R>>	LeftAll.checkedApply(Monoid<L> lMonoid)
Monoid<Either<L,R>>	LeftAny.checkedApply(Monoid<L> lMonoid)
Monoid<Either<L,R>>	Merge.checkedApply(Semigroup<L> lSemigroup, Monoid<R> rMonoid)
Monoid<Either<L,R>>	RightAll.checkedApply(Monoid<R> rMonoid)
Monoid<Either<L,R>>	RightAny.checkedApply(Monoid<R> rMonoid)
static <L, R> Monoid<Either<L,R>>	LeftAll.leftAll(Monoid<L> lMonoid)
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>>	LeftAll.leftAll(Monoid<L> lMonoid, Either<L,R> x)
static <L, R> Monoid<Either<L,R>>	LeftAny.leftAny(Monoid<L> lMonoid)
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>>	LeftAny.leftAny(Monoid<L> lMonoid, Either<L,R> x)
static <L, R> MonoidFactory<Monoid<R>,Either<L,R>>	Merge.merge(Semigroup<L> lSemigroup)
static <L, R> Monoid<Either<L,R>>	Merge.merge(Semigroup<L> lSemigroup, Monoid<R> rMonoid)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	Merge.merge(Semigroup<L> lSemigroup, Monoid<R> rMonoid, 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 <L, R> Monoid<Either<L,R>>	RightAll.rightAll(Monoid<R> rMonoid)
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>>	RightAll.rightAll(Monoid<R> rMonoid, Either<L,R> x)
static <L, R> Monoid<Either<L,R>>	RightAny.rightAny(Monoid<R> rMonoid)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	RightAny.rightAny(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)

Methods in com.jnape.palatable.lambda.monoid.builtin with parameters of type Either

Modifier and Type	Method	Description
static <L, R> Fn1<Either<L,R>,Either<L,R>>	LeftAll.leftAll(Monoid<L> lMonoid, Either<L,R> x)
static <L, R> Either<L,R>	LeftAll.leftAll(Monoid<L> lMonoid, Either<L,R> x, Either<L,R> y)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	LeftAny.leftAny(Monoid<L> lMonoid, Either<L,R> x)
static <L, R> Either<L,R>	LeftAny.leftAny(Monoid<L> lMonoid, Either<L,R> x, Either<L,R> y)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	Merge.merge(Semigroup<L> lSemigroup, Monoid<R> rMonoid, Either<L,R> x)
static <L, R> Either<L,R>	Merge.merge(Semigroup<L> lSemigroup, Monoid<R> rMonoid, Either<L,R> x, Either<L,R> y)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	RightAll.rightAll(Monoid<R> rMonoid, Either<L,R> x)
static <L, R> Either<L,R>	RightAll.rightAll(Monoid<R> rMonoid, Either<L,R> x, Either<L,R> y)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	RightAny.rightAny(Monoid<R> rMonoid, Either<L,R> x)
static <L, R> Either<L,R>	RightAny.rightAny(Monoid<R> rMonoid, Either<L,R> x, Either<L,R> y)

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

Methods in com.jnape.palatable.lambda.optics that return types with arguments of type Either

Modifier and Type	Method	Description
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.

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

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

Modifier and Type	Method	Description
Either<T,A>	Matching.checkedApply(Optic<? super Market<A,B,?,?>,? super Identity<?>,S,T,A,B> optic, S s)
static <S, T, A, B> Either<T,A>	Matching.matching(Optic<? super Market<A,B,?,?>,? super Identity<?>,S,T,A,B> optic, S s)

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

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)

Uses of Either in com.jnape.palatable.lambda.optics.lenses

Methods in com.jnape.palatable.lambda.optics.lenses that return types with arguments of type Either

Modifier and Type	Method	Description
static <L, R> Lens.Simple<Either<L,R>,Maybe<L>>	EitherLens._left()	Convenience static factory method for creating a lens over left values, wrapping them in a Maybe.
static <L, R> Lens.Simple<Either<L,R>,Maybe<R>>	EitherLens._right()	Convenience static factory method for creating a lens over right values, wrapping them in a Maybe.

Uses of Either in com.jnape.palatable.lambda.optics.prisms

Methods in com.jnape.palatable.lambda.optics.prisms that return types with arguments of type Either

Modifier and Type	Method	Description
static <L, R> Prism.Simple<Either<L,R>,L>	EitherPrism._left()	A Prism that focuses on the left value of an Either.
static <L, R> Prism.Simple<Either<L,R>,R>	EitherPrism._right()	A Prism that focuses on the right value of an Either.

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

Methods in com.jnape.palatable.lambda.semigroup.builtin that return Either

Modifier and Type	Method	Description
static <L, R> Either<L,R>	LeftAll.leftAll(Semigroup<L> lSemigroup, Either<L,R> x, Either<L,R> y)
static <L, R> Either<L,R>	LeftAny.leftAny(Semigroup<L> lSemigroup, Either<L,R> x, Either<L,R> y)
static <L, R> Either<L,R>	Merge.merge(Semigroup<L> lSemigroup, Semigroup<R> rSemigroup, Either<L,R> x, Either<L,R> y)
static <L, R> Either<L,R>	RightAll.rightAll(Semigroup<R> rSemigroup, Either<L,R> x, Either<L,R> y)
static <L, R> Either<L,R>	RightAny.rightAny(Semigroup<R> rSemigroup, Either<L,R> x, Either<L,R> y)

Methods in com.jnape.palatable.lambda.semigroup.builtin that return types with arguments of type Either

Modifier and Type	Method	Description
Semigroup<Either<L,R>>	LeftAll.checkedApply(Semigroup<L> lSemigroup)
Semigroup<Either<L,R>>	LeftAny.checkedApply(Semigroup<L> lSemigroup)
Semigroup<Either<L,R>>	Merge.checkedApply(Semigroup<L> lSemigroup, Semigroup<R> rSemigroup)
Semigroup<Either<L,R>>	RightAll.checkedApply(Semigroup<R> rSemigroup)
Semigroup<Either<L,R>>	RightAny.checkedApply(Semigroup<R> rSemigroup)
static <L, R> Semigroup<Either<L,R>>	LeftAll.leftAll(Semigroup<L> lSemigroup)
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>>	LeftAll.leftAll(Semigroup<L> lSemigroup, Either<L,R> x)
static <L, R> Semigroup<Either<L,R>>	LeftAny.leftAny(Semigroup<L> lSemigroup)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	LeftAny.leftAny(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 <L, R> SemigroupFactory<Semigroup<R>,Either<L,R>>	Merge.merge(Semigroup<L> lSemigroup)
static <L, R> Semigroup<Either<L,R>>	Merge.merge(Semigroup<L> lSemigroup, Semigroup<R> rSemigroup)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	Merge.merge(Semigroup<L> lSemigroup, Semigroup<R> rSemigroup, Either<L,R> x)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	Merge.merge(Semigroup<L> lSemigroup, Semigroup<R> rSemigroup, Either<L,R> x)
static <L, R> Semigroup<Either<L,R>>	RightAll.rightAll(Semigroup<R> rSemigroup)
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>>	RightAll.rightAll(Semigroup<R> rSemigroup, Either<L,R> x)
static <L, R> Semigroup<Either<L,R>>	RightAny.rightAny(Semigroup<R> rSemigroup)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	RightAny.rightAny(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)

Methods in com.jnape.palatable.lambda.semigroup.builtin with parameters of type Either

Modifier and Type	Method	Description
static <L, R> Fn1<Either<L,R>,Either<L,R>>	LeftAll.leftAll(Semigroup<L> lSemigroup, Either<L,R> x)
static <L, R> Either<L,R>	LeftAll.leftAll(Semigroup<L> lSemigroup, Either<L,R> x, Either<L,R> y)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	LeftAny.leftAny(Semigroup<L> lSemigroup, Either<L,R> x)
static <L, R> Either<L,R>	LeftAny.leftAny(Semigroup<L> lSemigroup, Either<L,R> x, Either<L,R> y)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	Merge.merge(Semigroup<L> lSemigroup, Semigroup<R> rSemigroup, Either<L,R> x)
static <L, R> Either<L,R>	Merge.merge(Semigroup<L> lSemigroup, Semigroup<R> rSemigroup, Either<L,R> x, Either<L,R> y)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	RightAll.rightAll(Semigroup<R> rSemigroup, Either<L,R> x)
static <L, R> Either<L,R>	RightAll.rightAll(Semigroup<R> rSemigroup, Either<L,R> x, Either<L,R> y)
static <L, R> Fn1<Either<L,R>,Either<L,R>>	RightAny.rightAny(Semigroup<R> rSemigroup, Either<L,R> x)
static <L, R> Either<L,R>	RightAny.rightAny(Semigroup<R> rSemigroup, Either<L,R> x, Either<L,R> y)