Package fj.data.optic

Class PIso<S,T,A,B>

java.lang.Object
fj.data.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 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> F<S,F<C,T>> modifyFunctionF(F<A,F<C,B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modifyEitherF

      public final <L> F<S,Either<L,T>> modifyEitherF(F<A,Either<L,B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modifyIOF

      public final F<S,IO<T>> modifyIOF(F<A,IO<B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modifyTrampolineF

      public final F<S,Trampoline<T>> modifyTrampolineF(F<A,Trampoline<B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modifyPromiseF

      public final F<S,Promise<T>> modifyPromiseF(F<A,Promise<B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modifyListF

      public final F<S,List<T>> modifyListF(F<A,List<B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modifyOptionF

      public final F<S,Option<T>> modifyOptionF(F<A,Option<B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modifyStreamF

      public final F<S,Stream<T>> modifyStreamF(F<A,Stream<B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modifyP1F

      public final F<S,P1<T>> modifyP1F(F<A,P1<B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modifyValidationF

      public final <E> F<S,Validation<E,T>> modifyValidationF(F<A,Validation<E,B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modifyV2F

      public final F<S,V2<T>> modifyV2F(F<A,V2<B>> f)
      modify polymorphically the target of a PIso with an Applicative function
    • modify

      public final F<S,T> modify(F<A,B> f)
      modify polymorphically the target of a PIso with a function
    • set

      public final F<S,T> set(B b)
      set polymorphically the target of a PIso with a value
    • product

      public final <S1, T1, A1, B1> PIso<P2<S,S1>,P2<T,T1>,P2<A,A1>,P2<B,B1>> product(PIso<S1,T1,A1,B1> other)
      pair two disjoint PIso
    • first

      public <C> PIso<P2<S,C>,P2<T,C>,P2<A,C>,P2<B,C>> first()
    • second

      public <C> PIso<P2<C,S>,P2<C,T>,P2<C,A>,P2<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(F<S,A> get, F<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, ...)