Interface Iso.Simple<S,A>

Type Parameters:
S - the type of both "larger" values
A - the type of both "smaller" values
All Superinterfaces:
Applicative<S,Iso<S,?,A,A>>, Contravariant<S,Profunctor<?,S,Iso<?,?,A,A>>>, Functor<S,Iso<S,?,A,A>>, Iso<S,S,A,A>, Monad<S,Iso<S,?,A,A>>, MonadRec<S,Iso<S,?,A,A>>, Optic<Profunctor<?,?,?>,Functor<?,?>,S,S,A,A>, Optic.Simple<Profunctor<?,?,?>,Functor<?,?>,S,A>, Profunctor<S,S,Iso<?,?,A,A>>
All Known Subinterfaces:
TypeSafeKey<A,B>, TypeSafeKey.Simple<A>
Enclosing interface:
Iso<S,T,A,B>
Functional Interface:
This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface public static interface Iso.Simple<S,A> extends Iso<S,S,A,A>, Optic.Simple<Profunctor<?,?,?>,Functor<?,?>,S,A>
A convenience type with a simplified type signature for common isos with both unified "larger" values and unified "smaller" values.
  • Method Details

    • compose

      default <R> Iso.Simple<R,A> compose(Iso.Simple<R,S> g)
      Compose two simple isos from right to left.
      Type Parameters:
      R - the other simple iso' larger type
      Parameters:
      g - the other simple iso
      Returns:
      the composed simple iso
    • andThen

      default <B> Iso.Simple<S,B> andThen(Iso.Simple<A,B> f)
      Compose two simple isos from left to right.
      Type Parameters:
      B - the other simple iso' smaller type
      Parameters:
      f - the other simple iso
      Returns:
      the composed simple iso
    • mirror

      default Iso.Simple<A,S> mirror()
      Flip this Iso around.
      Specified by:
      mirror in interface Iso<S,S,A,A>
      Returns:
      the mirrored Iso
    • toLens

      default Lens.Simple<S,A> toLens()
      Convert this Iso into a Lens.
      Specified by:
      toLens in interface Iso<S,S,A,A>
      Returns:
      the equivalent lens
    • discardR

      default <U> Iso.Simple<S,A> discardR(Applicative<U,Iso<S,?,A,A>> appB)
      Sequence both this Applicative and appB, discarding appB's result and returning this Applicative. This is generally useful for sequentially performing side-effects.
      Specified by:
      discardR in interface Applicative<S,A>
      Specified by:
      discardR in interface Iso<S,S,A,A>
      Specified by:
      discardR in interface Monad<S,A>
      Specified by:
      discardR in interface MonadRec<S,A>
      Type Parameters:
      U - the type of appB's parameter
      Parameters:
      appB - the other Applicative
      Returns:
      this Applicative
    • andThen

      default <B> Iso.Simple<S,B> andThen(Optic.Simple<? super Profunctor<?,?,?>,? super Functor<?,?>,A,B> f)
      Compose two simple optics from left to right.
      Specified by:
      andThen in interface Optic.Simple<Profunctor<?,?,?>,Functor<?,?>,S,A>
      Type Parameters:
      B - the new left side and right side's functor embedding of the input profunctor
      Parameters:
      f - the other simple optic
      Returns:
      the composed simple optic
    • compose

      default <R> Iso.Simple<R,A> compose(Optic.Simple<? super Profunctor<?,?,?>,? super Functor<?,?>,R,S> g)
      Compose two simple optics from right to left.
      Specified by:
      compose in interface Optic.Simple<Profunctor<?,?,?>,Functor<?,?>,S,A>
      Type Parameters:
      R - the new left side and right side's functor embedding of the output profunctor
      Parameters:
      g - the other simple optic
      Returns:
      the composed simple optic
    • adapt

      static <S, A> Iso.Simple<S,A> adapt(Optic<? super Profunctor<?,?,?>,? super Functor<?,?>,S,S,A,A> optic)
      Adapt an Optic with the right variance to an Iso.Simple.
      Type Parameters:
      S - S/T
      A - A/B
      Parameters:
      optic - the optic
      Returns:
      the simple iso