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 Detail

      • 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
      • 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