Class PIso<S,T,A,B>

java.lang.Object

io.atlassian.fugue.optic.PIso<S,T,A,B>

Type Parameters:

S - the source of a PIso

T - the modified source of a PIso

A - the target of a PIso

B - the modified target of a PIso

Direct Known Subclasses:

Iso

public abstract class PIso<S,T,A,B>
extends Object

A PIso defines an isomorphism between types S, A and B, T:

             get                           reverse.get
    -------------------->             -------------------->
  S                       A         T                       B
    <--------------------             <--------------------
      reverse.reverseGet                   reverseGet

In addition, if f and g forms an isomorphism between `A` and `B`, i.e. if `f . g = id` and `g . f = id`, then a PIso defines an isomorphism between `S` and `T`:

    S           T                                   S           T
    |           ↑                                   ↑           |
    |           |                                   |           |
get |           | reverseGet     reverse.reverseGet |           | reverse.get
    |           |                                   |           |
    ↓     f     |                                   |     g     ↓
    A --------> B                                   A <-------- B

A PIso is also a valid Getter, Fold, PLens, PPrism, POptional, PTraversal and PSetter

Constructor Summary

Constructors

Constructor	Description
PIso()

Method Summary

Modifier and Type	Method	Description
final Fold<S,A>	asFold()	view a PIso as a Fold
final Getter<S,A>	asGetter()	view a PIso as a Getter
PLens<S,T,A,B>	asLens()	view a PIso as a PLens
POptional<S,T,A,B>	asOptional()	view a PIso as a POptional
PPrism<S,T,A,B>	asPrism()	view a PIso as a PPrism
PSetter<S,T,A,B>	asSetter()	view a PIso as a Setter
PTraversal<S,T,A,B>	asTraversal()	view a PIso as a PTraversal
final <C> Fold<S,C>	composeFold(Fold<A,C> other)	compose a PIso with a Fold
final <C> Getter<S,C>	composeGetter(Getter<A,C> other)	compose a PIso with a Getter
final <C,D> PIso<S,T,C,D>	composeIso(PIso<A,B,C,D> other)	compose a PIso with a PIso
final <C,D> PLens<S,T,C,D>	composeLens(PLens<A,B,C,D> other)	compose a PIso with a PLens
final <C,D> POptional<S,T,C,D>	composeOptional(POptional<A,B,C,D> other)	compose a PIso with a POptional
final <C,D> PPrism<S,T,C,D>	composePrism(PPrism<A,B,C,D> other)	compose a PIso with a PPrism
final <C,D> PSetter<S,T,C,D>	composeSetter(PSetter<A,B,C,D> other)	compose a PIso with a PSetter
final <C,D> PTraversal<S,T,C,D>	composeTraversal(PTraversal<A,B,C,D> other)	compose a PIso with a PTraversal
<C> PIso<Pair<S,C>, Pair<T,C>, Pair<A,C>, Pair<B,C>>	first()
abstract A	get(S s)	get the target of a PIso
final Function<S,T>	modify(Function<A,B> f)	modify polymorphically the target of a PIso with a function
final <L> Function<S, Either<L,T>>	modifyEitherF(Function<A, Either<L,B>> f)	modify polymorphically the target of a PIso with an Applicative function
final <C> Function<S, Function<C,T>>	modifyFunctionF(Function<A, Function<C,B>> f)	modify polymorphically the target of a PIso with an Applicative function
final Function<S, Iterable<T>>	modifyIterableF(Function<A, Iterable<B>> f)	modify polymorphically the target of a PIso with an Applicative function
final Function<S, Option<T>>	modifyOptionF(Function<A, Option<B>> f)	modify polymorphically the target of a PIso with an Applicative function
final Function<S, Pair<T,T>>	modifyPairF(Function<A, Pair<B,B>> f)	modify polymorphically the target of a PIso with an Applicative function
final Function<S, Supplier<T>>	modifySupplierF(Function<A, Supplier<B>> f)	modify polymorphically the target of a PIso with an Applicative function
static <S,T> PIso<S,T,S,T>	pId()	create a PIso between any type and itself.
static <S,T,A,B> PIso<S,T,A,B>	pIso(Function<S,A> get, Function<B,T> reverseGet)	create a PIso using a pair of functions: one to get the target and one to get the source.
<S1,T1,A1,B1> PIso<Pair<S,S1>, Pair<T,T1>, Pair<A,A1>, Pair<B,B1>>	product(PIso<S1,T1,A1,B1> other)	pair two disjoint PIso
abstract PIso<B,A,T,S>	reverse()	reverse a PIso: the source becomes the target and the target becomes the source
abstract T	reverseGet(B b)	get the modified source of a PIso
<C> PIso<Pair<C,S>, Pair<C,T>, Pair<C,A>, Pair<C,B>>	second()
final Function<S,T>	set(B b)	set polymorphically the target of a PIso with a value

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

PIso

PIso()

Method Details

get

public abstract A get(S s)

get the target of a PIso

reverseGet

public abstract T reverseGet(B b)

get the modified source of a PIso

reverse

public abstract PIso<B,A,T,S> reverse()

reverse a PIso: the source becomes the target and the target becomes the source

modifyFunctionF

public final <C> Function<S, Function<C,T>> modifyFunctionF(Function<A, Function<C,B>> f)

modify polymorphically the target of a PIso with an Applicative function

modifyEitherF

public final <L> Function<S, Either<L,T>> modifyEitherF(Function<A, Either<L,B>> f)

modify polymorphically the target of a PIso with an Applicative function

modifyOptionF

public final Function<S, Option<T>> modifyOptionF(Function<A, Option<B>> f)

modify polymorphically the target of a PIso with an Applicative function

modifyIterableF

public final Function<S, Iterable<T>> modifyIterableF(Function<A, Iterable<B>> f)

modify polymorphically the target of a PIso with an Applicative function

modifySupplierF

public final Function<S, Supplier<T>> modifySupplierF(Function<A, Supplier<B>> f)

modify polymorphically the target of a PIso with an Applicative function

modifyPairF

public final Function<S, Pair<T,T>> modifyPairF(Function<A, Pair<B,B>> f)

modify polymorphically the target of a PIso with an Applicative function

modify

public final Function<S,T> modify(Function<A,B> f)

modify polymorphically the target of a PIso with a function

set

public final Function<S,T> set(B b)

set polymorphically the target of a PIso with a value

product

public <S1,T1,A1,B1>
PIso<Pair<S,S1>, Pair<T,T1>, Pair<A,A1>, Pair<B,B1>> product(PIso<S1,T1,A1,B1> other)

pair two disjoint PIso

first

public <C>
PIso<Pair<S,C>, Pair<T,C>, Pair<A,C>, Pair<B,C>> first()

second

public <C>
PIso<Pair<C,S>, Pair<C,T>, Pair<C,A>, Pair<C,B>> second()

composeFold

public final <C> Fold<S,C> composeFold(Fold<A,C> other)

compose a PIso with a Fold

composeGetter

public final <C> Getter<S,C> composeGetter(Getter<A,C> other)

compose a PIso with a Getter

composeSetter

public final <C,D> PSetter<S,T,C,D> composeSetter(PSetter<A,B,C,D> other)

compose a PIso with a PSetter

composeTraversal

public final <C,D> PTraversal<S,T,C,D> composeTraversal(PTraversal<A,B,C,D> other)

compose a PIso with a PTraversal

composeOptional

public final <C,D> POptional<S,T,C,D> composeOptional(POptional<A,B,C,D> other)

compose a PIso with a POptional

composePrism

public final <C,D> PPrism<S,T,C,D> composePrism(PPrism<A,B,C,D> other)

compose a PIso with a PPrism

composeLens

public final <C,D> PLens<S,T,C,D> composeLens(PLens<A,B,C,D> other)

compose a PIso with a PLens

composeIso

public final <C,D> PIso<S,T,C,D> composeIso(PIso<A,B,C,D> other)

compose a PIso with a PIso

asFold

public final Fold<S,A> asFold()

view a PIso as a Fold

asGetter

public final Getter<S,A> asGetter()

view a PIso as a Getter

asSetter

public PSetter<S,T,A,B> asSetter()

view a PIso as a Setter

asTraversal

public PTraversal<S,T,A,B> asTraversal()

view a PIso as a PTraversal

asOptional

public POptional<S,T,A,B> asOptional()

view a PIso as a POptional

asPrism

public PPrism<S,T,A,B> asPrism()

view a PIso as a PPrism

asLens

public PLens<S,T,A,B> asLens()

view a PIso as a PLens

pIso

public static <S,T,A,B> PIso<S,T,A,B> pIso(Function<S,A> get,
 Function<B,T> reverseGet)

create a PIso using a pair of functions: one to get the target and one to get the source.

pId

public static <S,T> PIso<S,T,S,T> pId()

create a PIso between any type and itself. id is the zero element of optics composition, for all optics o of type O (e.g. Lens, Iso, Prism, ...):

 o composeIso Iso.id == o
 Iso.id composeO o == o

(replace composeO by composeLens, composeIso, composePrism, ...)