com.jnape.palatable.lambda.optics

## Interface Optic.Simple<P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,A>

- Type Parameters:
    `P` - the `Profunctor` bound
    `F` - the `Functor` bound
    `S` - the left side and right side's functor embedding of the output profunctor
    `A` - the left side and right side's functor embedding of the input profunctor
  All Superinterfaces:
    Optic<P,F,S,S,A,A>
  All Known Subinterfaces:
    Iso.Simple<S,A>, Lens.Simple<S,A>, Schema<Values>, TypeSafeKey<A,B>, TypeSafeKey.Simple<A>
  Enclosing interface:
    Optic<P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,T,A,B>

      public static interface Optic.Simple<P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,A>
      extends Optic<P,F,S,S,A,A>

  An convenience type with a simplified signature for `optics` with unified `S/T` and `A/B` types.

- - ### Nested Class Summary

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

      `Optic.Simple<P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,A>`

  - ### Method Summary

    All Methods Static Methods Instance Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,A> Optic.Simple<P,F,S,A>` | `adapt(Optic<? super P,? super F,S,S,A,A> optic)` Adapt an `Optic` with S/T and A/B unified into a `simple optic`.
    `default <B> Optic.Simple<P,F,S,B>` | `andThen(Optic.Simple<? super P,? super F,A,B> f)` Compose two simple optics from left to right.
    `default <R> Optic.Simple<P,F,R,A>` | `compose(Optic.Simple<? super P,? super F,R,S> g)` Compose two simple optics from right to left.

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

      `andThen, apply, compose, mapA, mapB, mapS, mapT, monomorphize, optic, reframe`

- - ### Method Detail

    - #### andThen

          default <B> Optic.Simple<P,F,S,B> andThen(Optic.Simple<? super P,? super F,A,B> f)

      Compose two simple optics from left to right.
      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> Optic.Simple<P,F,R,A> compose(Optic.Simple<? super P,? super F,R,S> g)

      Compose two simple optics from right to left.
      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 <P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,A> Optic.Simple<P,F,S,A> adapt(Optic<? super P,? super F,S,S,A,A> optic)

      Adapt an `Optic` with S/T and A/B unified into a `simple optic`.
      Type Parameters:
        `P` - the `Profunctor` bound
        `F` - the `Functor` bound
        `S` - the left side and the right side's functor embedding of the output profunctor
        `A` - the left side and the right side's functor embedding of the input profunctor
      Parameters:
        `optic` - the `Optic`
      Returns:
        the `Optic.Simple` optic