com.jnape.palatable.lambda.optics

## 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.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface com.jnape.palatable.lambda.optics.Iso

      `Iso.Simple<S,A>`

  - ### Method Summary

    All Methods Static Methods Instance Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `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`.
    `default <B> Iso.Simple<S,B>` | `andThen(Iso.Simple<A,B> f)` Compose two simple isos from left to right.
    `default <B> Iso.Simple<S,B>` | `andThen(Optic.Simple<? super Profunctor<?,?,?>,? super Functor<?,?>,A,B> f)` Compose two simple optics from left to right.
    `default <R> Iso.Simple<R,A>` | `compose(Iso.Simple<R,S> g)` Compose two simple isos from right to left.
    `default <R> Iso.Simple<R,A>` | `compose(Optic.Simple<? super Profunctor<?,?,?>,? super Functor<?,?>,R,S> g)` Compose two simple optics from right to left.
    `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`.
    `default Iso.Simple<A,S>` | `mirror()` Flip this `Iso` around.
    `default Lens.Simple<S,A>` | `toLens()` Convert this `Iso` into a `Lens`.

    - ### Methods inherited from interface com.jnape.palatable.lambda.optics.Iso

      `andThen, compose, contraMap, diMap, diMapL, diMapR, discardL, flatMap, fmap, iso, iso, mapA, mapB, mapS, mapT, pure, pureIso, simpleIso, trampolineM, unIso, zip`

    - ### Methods inherited from interface com.jnape.palatable.lambda.monad.MonadRec

      `lazyZip`

    - ### Methods inherited from interface com.jnape.palatable.lambda.monad.Monad

      `join`

    - ### Methods inherited from interface com.jnape.palatable.lambda.functor.Functor

      `coerce`

    - ### Methods inherited from interface com.jnape.palatable.lambda.optics.Optic.Simple

      `adapt`

    - ### Methods inherited from interface com.jnape.palatable.lambda.optics.Optic

      `apply, monomorphize, optic, reframe`

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

    - #### 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,Iso<S,?,A,A>>`
      Specified by:
        `discardR` in interface `Iso<S,S,A,A>`
      Specified by:
        `discardR` in interface `Monad<S,Iso<S,?,A,A>>`
      Specified by:
        `discardR` in interface `MonadRec<S,Iso<S,?,A,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