Uses of Class
io.atlassian.fugue.Either

Packages that use Either

Package	Description
io.atlassian.fugue
io.atlassian.fugue.extensions.step
io.atlassian.fugue.hamcrest
io.atlassian.fugue.optic
io.atlassian.fugue.optic.law
io.atlassian.fugue.optic.std

Uses of Either in io.atlassian.fugue

Subclasses of Either in io.atlassian.fugue

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

Methods in io.atlassian.fugue that return Either

Modifier and Type	Method	Description
<X> Either<L,X>	Either.ap(Either<L, Function<R,X>> either)	Function application on this projection's value.
<X> Either<X,R>	Either.LeftProjection.ap(Either<Function<L,X>, R> either)	Function application on this projection's value.
<X> Either<L,X>	Either.RightProjection.ap(Either<L, Function<R,X>> either)	Function application on this projection's value.
<X> Either<L,X>	Either.apply(Either<L, Function<R,X>> either)	Deprecated. since 3.0 see Either.ap(Either)
<X> Either<X,R>	Either.LeftProjection.apply(Either<Function<L,X>, R> either)	Deprecated. since 3.0
<X> Either<L,X>	Either.RightProjection.apply(Either<L, Function<R,X>> either)	Deprecated. since 3.0 see ap
(package private) <X> Either<L,X>	Either.LeftProjection.as()	Coerces our right type as X.
(package private) <X> Either<X,R>	Either.RightProjection.as()	Coerces our left type as X.
abstract <LL,RR> Either<LL,RR>	Either.bimap(Function<? super L, ? extends LL> ifLeft, Function<? super R, ? extends RR> ifRight)	Map the given functions across the appropriate side.
<LL,RR> Either<LL,RR>	Either.Left.bimap(Function<? super L, ? extends LL> ifLeft, Function<? super R, ? extends RR> ifRight)
<LL,RR> Either<LL,RR>	Either.Right.bimap(Function<? super L, ? extends LL> ifLeft, Function<? super R, ? extends RR> ifRight)
static <L,R> Either<L,R>	Eithers.cond(boolean predicate, L left, R right)	Creates an Either based on a boolean expression.
final Either<L,R>	Either.AbstractProjection.either()
Either<L,R>	Either.Projection.either()	The either value underlying this projection.
final Either<L,R>	Either.filterOrElse(Predicate<? super R> p, Supplier<? extends L> orElseSupplier)	Return a Right if this is a Right and the contained values satisfies the given predicate.
Either<L,R>	Either.LeftProjection.filterOrElse(Predicate<? super L> p, Supplier<? extends R> orElseSupplier)	Return a Left if this is a Left and the contained values satisfies the given predicate.
Either<L,R>	Either.RightProjection.filterOrElse(Predicate<? super R> p, Supplier<? extends L> orElseSupplier)	Return a Right if this is a Right and the contained values satisfies the given predicate.
final <X, LL extends L> Either<L,X>	Either.flatMap(Function<? super R, Either<LL,X>> f)	Binds the given function across the right hand side value if it is one.
<X, RR extends R> Either<X,R>	Either.LeftProjection.flatMap(Function<? super L, Either<X,RR>> f)	Binds the given function across this projection's value if it has one.
<X, LL extends L> Either<L,X>	Either.RightProjection.flatMap(Function<? super R, Either<LL,X>> f)	Binds the given function across this projection's value if it has one.
static <L,R> Either<L,R>	Either.left(L left)	left.
final <X> Either<X,R>	Either.leftMap(Function<? super L, X> f)	Map the given function across the left hand side value if it is one.
<X> Either<X,R>	Either.LeftProjection.map(Function<? super L, X> f)	Map the given function across this projection's value if it has one.
final <X> Either<L,X>	Either.map(Function<? super R, X> f)	Map the given function across the right hand side value if it is one.
<X> Either<L,X>	Either.RightProjection.map(Function<? super R, X> f)	Map the given function across this projection's value if it has one.
final Either<L,R>	Either.orElse(Either<? extends L, ? extends R> orElse)	If this is a right, return the same right.
final Either<L,R>	Either.orElse(Supplier<? extends Either<? extends L, ? extends R>> orElse)	If this is a right, return the same right.
static <L,R> Either<L,R>	Either.right(R right)	right.
<X> Either<X,R>	Either.LeftProjection.sequence(Either<X,R> e)	Anonymous bind through this projection.
<X> Either<L,X>	Either.RightProjection.sequence(Either<L,X> e)	Anonymous bind through this projection.
<X> Either<L,X>	Either.sequence(Either<L,X> e)	Will return the supplied Either if this one is right, otherwise this one if left.
static <L,R> Either<Iterable<L>, R>	Eithers.sequenceLeft(Iterable<Either<L,R>> eithers)	Collect the left values if there are only lefts, otherwise return the first right encountered.
static <L,R,A,C> Either<C,R>	Eithers.sequenceLeft(Iterable<Either<L,R>> eithers, Collector<L,A,C> collector)	Collect the left values if there are only lefts, otherwise return the first right encountered.
static <L,R> Either<L, Iterable<R>>	Eithers.sequenceRight(Iterable<Either<L,R>> eithers)	Collect the right values if there are only rights, otherwise return the first left encountered.
static <L,R,A,C> Either<L,C>	Eithers.sequenceRight(Iterable<Either<L,R>> eithers, Collector<R,A,C> collector)	Collect the right values if there are only rights, otherwise return the first left encountered.
Either<R,L>	Either.Left.swap()
Either<R,L>	Either.Right.swap()
abstract Either<R,L>	Either.swap()	If this is a left, then return the left value in right, or vice versa.
Either<Exception, A>	Try.Delayed.toEither()
Either<Exception, A>	Try.Failure.toEither()
Either<Exception, A>	Try.Success.toEither()
abstract Either<Exception, A>	Try.toEither()	Convert this Try to an Either, becoming a left if this is a failure and a right if this is a success.
final <X> Either<A,X>	Option.toLeft(Supplier<X> right)	Creates an Either from this Option.
final <X> Either<X,A>	Option.toRight(Supplier<X> left)	Creates an Either from this Option.
static <LL, L extends LL, R> Either<LL,R>	Eithers.upcastLeft(Either<L,R> e)	Upcasts an either of left type L to an either of left type LL, which is a super type of L, keeping the right type unchanged.
static <L, RR, R extends RR> Either<L,RR>	Eithers.upcastRight(Either<L,R> e)	Upcasts an either of right type R to an either of right type RR, which is a super type of R, keeping the left type unchanged.

Methods in io.atlassian.fugue that return types with arguments of type Either

Modifier and Type	Method	Description
static <L,R> Monoid<Either<L,R>>	Monoids.either(Semigroup<L> lS, Monoid<R> rM)	A monoid Sums up values inside either Semigroups.either(Semigroup, Semigroup).
static <L,R> Semigroup<Either<L,R>>	Semigroups.either(Semigroup<L> lS, Semigroup<R> rS)	Sums up values inside either, if both are left or right.
final Option<Either<L,R>>	Either.filter(Predicate<? super R> p)	Returns None if this is a left or if the given predicate p does not hold for the contained value, otherwise, returns a right in Some.
<X> Option<Either<L,X>>	Either.LeftProjection.filter(Predicate<? super L> f)	Returns None if this projection has no value or if the given predicate p does not hold for the value, otherwise, returns a left in Some.
<X> Option<Either<X,R>>	Either.RightProjection.filter(Predicate<? super R> f)	Returns None if this projection has no value or if the given predicate p does not hold for the value, otherwise, returns a right in Some.
static <L,R> Predicate<Either<L,R>>	Eithers.isLeft()	A predicate that tests if the supplied either is a left.
static <L,R> Predicate<Either<L,R>>	Eithers.isRight()	A predicate that tests if the supplied either is a right.
static <L,R> Function<Either<L,R>, Option<L>>	Eithers.leftMapper()	A function that maps an either to an option of its left type.
static <L,R> Function<Either<L,R>, Option<R>>	Eithers.rightMapper()	A function that maps an either to an option of its right type.
static <L,R> Collector<Either<L,R>, ?, Either<List<L>,R>>	FugueCollectors.toEitherLeft()	Collect the left values if there are only lefts, otherwise return the first right encountered.
static <L,R> Collector<Either<L,R>, ?, Either<List<L>,R>>	FugueCollectors.toEitherLeft()	Collect the left values if there are only lefts, otherwise return the first right encountered.
static <L,R,A,B> Collector<Either<L,R>, ?, Either<B,R>>	FugueCollectors.toEitherLeft(Collector<L,A,B> lCollector)	Collect the left values if there are only lefts, otherwise return the first right encountered.
static <L,R,A,B> Collector<Either<L,R>, ?, Either<B,R>>	FugueCollectors.toEitherLeft(Collector<L,A,B> lCollector)	Collect the left values if there are only lefts, otherwise return the first right encountered.
static <L,R> Collector<Either<L,R>, ?, Either<L,List<R>>>	FugueCollectors.toEitherRight()	Collect the right values if there are only rights, otherwise return the first left encountered.
static <L,R> Collector<Either<L,R>, ?, Either<L,List<R>>>	FugueCollectors.toEitherRight()	Collect the right values if there are only rights, otherwise return the first left encountered.
static <L,R,A,B> Collector<Either<L,R>, ?, Either<L,B>>	FugueCollectors.toEitherRight(Collector<R,A,B> rCollector)	Collect the right values if there are only rights, otherwise return the first left encountered.
static <L,R,A,B> Collector<Either<L,R>, ?, Either<L,B>>	FugueCollectors.toEitherRight(Collector<R,A,B> rCollector)	Collect the right values if there are only rights, otherwise return the first left encountered.
static <L,R> Function<L, Either<L,R>>	Eithers.toLeft()	Function to convert from an value to a Either.Left containing that value.
static <L,R> Function<L, Either<L,R>>	Eithers.toLeft(Class<L> leftType, Class<R> rightType)	Function to convert from a value to a Either.Left containing that value.
static <L,R> Supplier<Either<L,R>>	Eithers.toLeft(L l)	Supplier returning a Either.Left.
static <L,R> Supplier<Either<L,R>>	Eithers.toLeft(L l, Class<R> rightType)	Supplier returning a Either.Left.
static <L,R> Function<R, Either<L,R>>	Eithers.toRight()	Function to convert from an value to a Either.Right.
static <L,R> Function<R, Either<L,R>>	Eithers.toRight(Class<L> leftType, Class<R> rightType)	Function to convert from a value to a Either.Right containing that value.
static <L,R> Supplier<Either<L,R>>	Eithers.toRight(Class<L> leftType, R r)	Supplier returning a Either.Right.
static <L,R> Supplier<Either<L,R>>	Eithers.toRight(R r)	Supplier returning a Either.Right.

Methods in io.atlassian.fugue with parameters of type Either

Modifier and Type	Method	Description
<X> Either<L,X>	Either.ap(Either<L, Function<R,X>> either)	Function application on this projection's value.
<X> Either<X,R>	Either.LeftProjection.ap(Either<Function<L,X>, R> either)	Function application on this projection's value.
<X> Either<L,X>	Either.RightProjection.ap(Either<L, Function<R,X>> either)	Function application on this projection's value.
<X> Either<L,X>	Either.apply(Either<L, Function<R,X>> either)	Deprecated. since 3.0 see Either.ap(Either)
<X> Either<X,R>	Either.LeftProjection.apply(Either<Function<L,X>, R> either)	Deprecated. since 3.0
<X> Either<L,X>	Either.RightProjection.apply(Either<L, Function<R,X>> either)	Deprecated. since 3.0 see ap
static <X extends Exception, A> A	Eithers.getOrThrow(Either<X,A> either)	Simplifies extracting a value or throwing a checked exception from an Either.
static <T> T	Eithers.merge(Either<T,T> either)	Extracts an object from an Either, regardless of the side in which it is stored, provided both sides contain the same type.
final Either<L,R>	Either.orElse(Either<? extends L, ? extends R> orElse)	If this is a right, return the same right.
<X> Either<X,R>	Either.LeftProjection.sequence(Either<X,R> e)	Anonymous bind through this projection.
<X> Either<L,X>	Either.RightProjection.sequence(Either<L,X> e)	Anonymous bind through this projection.
<X> Either<L,X>	Either.sequence(Either<L,X> e)	Will return the supplied Either if this one is right, otherwise this one if left.
static <LL, L extends LL, R> Either<LL,R>	Eithers.upcastLeft(Either<L,R> e)	Upcasts an either of left type L to an either of left type LL, which is a super type of L, keeping the right type unchanged.
static <L, RR, R extends RR> Either<L,RR>	Eithers.upcastRight(Either<L,R> e)	Upcasts an either of right type R to an either of right type RR, which is a super type of R, keeping the left type unchanged.

Method parameters in io.atlassian.fugue with type arguments of type Either

Modifier and Type	Method	Description
static <L,R> Iterable<L>	Eithers.filterLeft(Iterable<Either<L,R>> it)	Takes an Iterable of eithers, and collects the left values of every either which has a left value
static <L,R> Iterable<R>	Eithers.filterRight(Iterable<Either<L,R>> it)	Takes an Iterable of eithers, and collects the right values of every either which has a left value
final <X, LL extends L> Either<L,X>	Either.flatMap(Function<? super R, Either<LL,X>> f)	Binds the given function across the right hand side value if it is one.
<X, RR extends R> Either<X,R>	Either.LeftProjection.flatMap(Function<? super L, Either<X,RR>> f)	Binds the given function across this projection's value if it has one.
<X, LL extends L> Either<L,X>	Either.RightProjection.flatMap(Function<? super R, Either<LL,X>> f)	Binds the given function across this projection's value if it has one.
final Either<L,R>	Either.orElse(Supplier<? extends Either<? extends L, ? extends R>> orElse)	If this is a right, return the same right.
static <L,R> Either<Iterable<L>, R>	Eithers.sequenceLeft(Iterable<Either<L,R>> eithers)	Collect the left values if there are only lefts, otherwise return the first right encountered.
static <L,R,A,C> Either<C,R>	Eithers.sequenceLeft(Iterable<Either<L,R>> eithers, Collector<L,A,C> collector)	Collect the left values if there are only lefts, otherwise return the first right encountered.
static <L,R> Either<L, Iterable<R>>	Eithers.sequenceRight(Iterable<Either<L,R>> eithers)	Collect the right values if there are only rights, otherwise return the first left encountered.
static <L,R,A,C> Either<L,C>	Eithers.sequenceRight(Iterable<Either<L,R>> eithers, Collector<R,A,C> collector)	Collect the right values if there are only rights, otherwise return the first left encountered.

Uses of Either in io.atlassian.fugue.extensions.step

Fields in io.atlassian.fugue.extensions.step declared as Either

Modifier and Type	Field	Description
private final Either<LEFT,A>	EitherStep1.either1
private final Either<LEFT,A>	EitherStep2.either1
private final Either<LEFT,A>	EitherStep3.either1
private final Either<LEFT,A>	EitherStep4.either1
private final Either<LEFT,A>	EitherStep5.either1
private final Either<LEFT,A>	EitherStep6.either1
private final Either<LEFT,B>	EitherStep2.either2
private final Either<LEFT,B>	EitherStep3.either2
private final Either<LEFT,B>	EitherStep4.either2
private final Either<LEFT,B>	EitherStep5.either2
private final Either<LEFT,B>	EitherStep6.either2
private final Either<LEFT,C>	EitherStep3.either3
private final Either<LEFT,C>	EitherStep4.either3
private final Either<LEFT,C>	EitherStep5.either3
private final Either<LEFT,C>	EitherStep6.either3
private final Either<LEFT,D>	EitherStep4.either4
private final Either<LEFT,D>	EitherStep5.either4
private final Either<LEFT,D>	EitherStep6.either4
private final Either<LEFT,E>	EitherStep5.either5
private final Either<LEFT,E>	EitherStep6.either5
private final Either<LEFT,F>	EitherStep6.either6

Methods in io.atlassian.fugue.extensions.step that return Either

Modifier and Type	Method	Description
<Z> Either<LEFT,Z>	EitherStep1.yield(Function<? super A, Z> functor)	Terminating step expression, that will provide the previous steps to this function and return the result as a Right
<Z> Either<LEFT,Z>	EitherStep2.yield(BiFunction<? super A, ? super B, Z> functor)	Terminating step expression, that will provide the previous steps to this function and return the result as a Right
<Z> Either<LEFT,Z>	EitherStep3.yield(Function3<? super A, ? super B, ? super C, Z> functor)	Terminating step expression, that will provide the previous steps to this function and return the result as a Right
<Z> Either<LEFT,Z>	EitherStep4.yield(Function4<? super A, ? super B, ? super C, ? super D, Z> functor)	Terminating step expression, that will provide the previous steps to this function and return the result as a Right
<Z> Either<LEFT,Z>	EitherStep5.yield(Function5<? super A, ? super B, ? super C, ? super D, ? super E, Z> functor)	Terminating step expression, that will provide the previous steps to this function and return the result as a Right
<Z> Either<LEFT,Z>	EitherStep6.yield(Function6<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, Z> functor)	Terminating step expression, that will provide the previous steps to this function and return the result as a Right

Methods in io.atlassian.fugue.extensions.step with parameters of type Either

Modifier and Type	Method	Description
static <A,LEFT> EitherStep1<A,LEFT>	Steps.begin(Either<LEFT,A> either)	Begin a new Steps expresison, using the Either type.

Method parameters in io.atlassian.fugue.extensions.step with type arguments of type Either

Modifier and Type	Method	Description
<B, LL extends LEFT> EitherStep2<A,B,LEFT>	EitherStep1.then(Function<? super A, Either<LL,B>> functor)	Apply the provided function with the previous Step results.
<B, LL extends LEFT> EitherStep2<A,B,LEFT>	EitherStep1.then(Supplier<Either<LL,B>> supplier)	Apply the provided supplier with the previous Step results.
<C, LL extends LEFT> EitherStep3<A,B,C,LEFT>	EitherStep2.then(BiFunction<? super A, ? super B, Either<LL,C>> functor)	Apply the provided function with the previous Step results.
<C, LL extends LEFT> EitherStep3<A,B,C,LEFT>	EitherStep2.then(Supplier<Either<LL,C>> supplier)	Apply the provided supplier with the previous Step results.
<D, LL extends LEFT> EitherStep4<A,B,C,D,LEFT>	EitherStep3.then(Function3<? super A, ? super B, ? super C, Either<LL,D>> functor)	Apply the provided function with the previous Step results.
<D, LL extends LEFT> EitherStep4<A,B,C,D,LEFT>	EitherStep3.then(Supplier<Either<LL,D>> supplier)	Apply the provided supplier with the previous Step results.
<E, LL extends LEFT> EitherStep5<A,B,C,D,E,LEFT>	EitherStep4.then(Function4<? super A, ? super B, ? super C, ? super D, Either<LL,E>> functor)	Apply the provided function with the previous Step results.
<E, LL extends LEFT> EitherStep5<A,B,C,D,E,LEFT>	EitherStep4.then(Supplier<Either<LL,E>> supplier)	Apply the provided supplier with the previous Step results.
<F, LL extends LEFT> EitherStep6<A,B,C,D,E,F,LEFT>	EitherStep5.then(Function5<? super A, ? super B, ? super C, ? super D, ? super E, Either<LL,F>> functor)	Apply the provided function with the previous Step results.
<F, LL extends LEFT> EitherStep6<A,B,C,D,E,F,LEFT>	EitherStep5.then(Supplier<Either<LL,F>> supplier)	Apply the provided supplier with the previous Step results.

Constructors in io.atlassian.fugue.extensions.step with parameters of type Either

Modifier	Constructor	Description
(package private)	EitherStep1(Either<LEFT,A> either1)
(package private)	EitherStep2(Either<LEFT,A> either1, Either<LEFT,B> either2)
(package private)	EitherStep3(Either<LEFT,A> either1, Either<LEFT,B> either2, Either<LEFT,C> either3)
(package private)	EitherStep4(Either<LEFT,A> either1, Either<LEFT,B> either2, Either<LEFT,C> either3, Either<LEFT,D> either4)
(package private)	EitherStep5(Either<LEFT,A> either1, Either<LEFT,B> either2, Either<LEFT,C> either3, Either<LEFT,D> either4, Either<LEFT,E> either5)
(package private)	EitherStep6(Either<LEFT,A> either1, Either<LEFT,B> either2, Either<LEFT,C> either3, Either<LEFT,D> either4, Either<LEFT,E> either5, Either<LEFT,F> either6)

Uses of Either in io.atlassian.fugue.hamcrest

Subclasses with type arguments of type Either in io.atlassian.fugue.hamcrest

Modifier and Type	Class	Description
private static class	EitherMatchers.LeftMatcher<L>
private static class	EitherMatchers.RightMatcher<R>

Methods in io.atlassian.fugue.hamcrest that return types with arguments of type Either

Modifier and Type	Method	Description
static <L> org.hamcrest.Matcher<Either<L,?>>	EitherMatchers.isLeft(org.hamcrest.Matcher<? super L> subMatcher)
static <R> org.hamcrest.Matcher<Either<?,R>>	EitherMatchers.isRight(org.hamcrest.Matcher<? super R> subMatcher)

Methods in io.atlassian.fugue.hamcrest with parameters of type Either

Modifier and Type	Method	Description
protected void	EitherMatchers.LeftMatcher.describeMismatchSafely(Either<L,?> actual, org.hamcrest.Description mismatchDescription)
protected void	EitherMatchers.RightMatcher.describeMismatchSafely(Either<?,R> actual, org.hamcrest.Description mismatchDescription)
protected boolean	EitherMatchers.LeftMatcher.matchesSafely(Either<L,?> actual)
protected boolean	EitherMatchers.RightMatcher.matchesSafely(Either<?,R> actual)

Uses of Either in io.atlassian.fugue.optic

Methods in io.atlassian.fugue.optic that return Either

Modifier and Type	Method	Description
Either<S,A>	Optional.getOrModify(S s)
abstract Either<T,A>	POptional.getOrModify(S s)	get the target of a POptional or modify the source in case there is no target
abstract Either<T,A>	PPrism.getOrModify(S s)	get the target of a PPrism or modify the source in case there is no target
Either<S,A>	Prism.getOrModify(S s)

Methods in io.atlassian.fugue.optic that return types with arguments of type Either

Modifier and Type	Method	Description
static <A> Fold<Either<A,A>, A>	Fold.codiagonal()
static <A> Getter<Either<A,A>, A>	Getter.codiagonal()
static <S> Setter<Either<S,S>, S>	Setter.codiagonal()
static <S> Traversal<Either<S,S>, S>	Traversal.codiagonal()
<L> Function<S, Either<L,S>>	Lens.modifyEitherF(Function<A, Either<L,A>> f)
<L> Function<S, Either<L,S>>	Optional.modifyEitherF(Function<A, Either<L,A>> f)
final <L> Function<S, Either<L,T>>	PIso.modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a PIso with an Applicative function
abstract <L> Function<S, Either<L,T>>	PLens.modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a PLens with an Applicative function
abstract <L> Function<S, Either<L,T>>	POptional.modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a POptional with an Applicative function
final <L> Function<S, Either<L,T>>	PPrism.modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a PPrism with an Applicative function
abstract <L> Function<S, Either<L,T>>	PTraversal.modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a PTraversal with an Applicative function
<L> Function<S, Either<L,S>>	Traversal.modifyEitherF(Function<A, Either<L,A>> f)
static <S,T> PSetter<Either<S,S>, Either<T,T>, S, T>	PSetter.pCodiagonal()
static <S,T> PSetter<Either<S,S>, Either<T,T>, S, T>	PSetter.pCodiagonal()
static <S,T> PTraversal<Either<S,S>, Either<T,T>, S, T>	PTraversal.pCodiagonal()
static <S,T> PTraversal<Either<S,S>, Either<T,T>, S, T>	PTraversal.pCodiagonal()
final <S1> Fold<Either<S,S1>, A>	Fold.sum(Fold<S1,A> other)	join two Fold with the same target
final <S1> Getter<Either<S,S1>, A>	Getter.sum(Getter<S1,A> other)	join two Getter with the same target
final <S1> Lens<Either<S,S1>, A>	Lens.sum(Lens<S1,A> other)	join two Lens with the same target
final <S1> Optional<Either<S,S1>, A>	Optional.sum(Optional<S1,A> other)	join two Optional with the same target
final <S1,T1> PLens<Either<S,S1>, Either<T,T1>, A, B>	PLens.sum(PLens<S1,T1,A,B> other)	join two PLens with the same target
final <S1,T1> PLens<Either<S,S1>, Either<T,T1>, A, B>	PLens.sum(PLens<S1,T1,A,B> other)	join two PLens with the same target
final <S1,T1> POptional<Either<S,S1>, Either<T,T1>, A, B>	POptional.sum(POptional<S1,T1,A,B> other)	join two POptional with the same target
final <S1,T1> POptional<Either<S,S1>, Either<T,T1>, A, B>	POptional.sum(POptional<S1,T1,A,B> other)	join two POptional with the same target
final <S1,T1> PSetter<Either<S,S1>, Either<T,T1>, A, B>	PSetter.sum(PSetter<S1,T1,A,B> other)	join two PSetter with the same target
final <S1,T1> PSetter<Either<S,S1>, Either<T,T1>, A, B>	PSetter.sum(PSetter<S1,T1,A,B> other)	join two PSetter with the same target
final <S1,T1> PTraversal<Either<S,S1>, Either<T,T1>, A, B>	PTraversal.sum(PTraversal<S1,T1,A,B> other)	join two PTraversal with the same target
final <S1,T1> PTraversal<Either<S,S1>, Either<T,T1>, A, B>	PTraversal.sum(PTraversal<S1,T1,A,B> other)	join two PTraversal with the same target
final <S1> Setter<Either<S,S1>, A>	Setter.sum(Setter<S1,A> other)	join two Setter with the same target
final <S1> Traversal<Either<S,S1>, A>	Traversal.sum(Traversal<S1,A> other)	join two Traversal with the same target

Method parameters in io.atlassian.fugue.optic with type arguments of type Either

Modifier and Type	Method	Description
<L> Function<S, Either<L,S>>	Lens.modifyEitherF(Function<A, Either<L,A>> f)
<L> Function<S, Either<L,S>>	Optional.modifyEitherF(Function<A, Either<L,A>> f)
final <L> Function<S, Either<L,T>>	PIso.modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a PIso with an Applicative function
abstract <L> Function<S, Either<L,T>>	PLens.modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a PLens with an Applicative function
abstract <L> Function<S, Either<L,T>>	POptional.modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a POptional with an Applicative function
final <L> Function<S, Either<L,T>>	PPrism.modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a PPrism with an Applicative function
abstract <L> Function<S, Either<L,T>>	PTraversal.modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a PTraversal with an Applicative function
<L> Function<S, Either<L,S>>	Traversal.modifyEitherF(Function<A, Either<L,A>> f)
static <S,T,A,B> POptional<S,T,A,B>	POptional.pOptional(Function<S, Either<T,A>> getOrModify, Function<B, Function<S,T>> set)	create a POptional using the canonical functions: getOrModify and set
static <S,T,A,B> PPrism<S,T,A,B>	PPrism.pPrism(Function<S, Either<T,A>> getOrModify, Function<B,T> reverseGet)	create a PPrism using the canonical functions: getOrModify and reverseGet

Uses of Either in io.atlassian.fugue.optic.law

Methods in io.atlassian.fugue.optic.law that return types with arguments of type Either

Modifier and Type	Method	Description
IsEq<Either<String,S>>	IsoLaws.modifyEitherFPoint(S s)	modifyF Applicative.point(_) = Applicative.point(_)
IsEq<Either<String,S>>	LensLaws.modifyEitherFPoint(S s)	modifyF Applicative.point(_) = Applicative.point(_)
IsEq<Either<String,S>>	OptionalLaws.modifyEitherFPoint(S s)	modifyF Applicative.point(_) = Applicative.point(_)
IsEq<Either<String,S>>	PrismLaws.modifyEitherFPoint(S s)	modifyF Applicative.point(_) = Applicative.point(_)
IsEq<Either<String,S>>	TraversalLaws.modifyEitherFPoint(S s)	modifyF Applicative.point(_) = Applicative.point(_)

Uses of Either in io.atlassian.fugue.optic.std

Methods in io.atlassian.fugue.optic.std that return types with arguments of type Either

Modifier and Type	Method	Description
static <A,B> Prism<Either<A,B>, A>	EitherOptics.left()
static <A,B,C> PPrism<Either<A,B>, Either<C,B>, A, C>	EitherOptics.pLeft()
static <A,B,C> PPrism<Either<A,B>, Either<C,B>, A, C>	EitherOptics.pLeft()
static <A,B,C> PPrism<Either<A,B>, Either<A,C>, B, C>	EitherOptics.pRight()
static <A,B,C> PPrism<Either<A,B>, Either<A,C>, B, C>	EitherOptics.pRight()
static <A,B> Prism<Either<A,B>, B>	EitherOptics.right()