com.jnape.palatable.lambda.optics

## Interface ProtoOptic<P extends Profunctor<?,?,? extends P>,S,T,A,B>

- Type Parameters:
    `P` - the `Profunctor` bound
    `S` - the left side of the output profunctor
    `T` - the right side's functor embedding of the output profunctor
    `A` - the left side of the input profunctor
    `B` - the right side's functor embedding of the input profunctor
  All Superinterfaces:
    Optic<P,Identity<?>,S,T,A,B>
  All Known Subinterfaces:
    Prism<S,T,A,B>, Prism.Simple<S,A>
  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 interface ProtoOptic<P extends Profunctor<?,?,? extends P>,S,T,A,B>
      extends Optic<P,Identity<?>,S,T,A,B>

  A generic supertype representation for a profunctor `Optic` that requires a `Pure` implementation to derive its `Functor` constraint and graduate to a full-fledge `Optic`, equipped with a default `Optic` instance for the profunctor constraint and `Identity`.

- - ### 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 Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default <Z,C> ProtoOptic<P,S,T,Z,C>` | `andThen(ProtoOptic<? super P,A,B,Z,C> f)` Left-to-right composition of proto-optics.
    `default <CoP extends Profunctor<?,?,? extends P>,CoF extends Functor<?,? extends Identity<?>>,FB extends Functor<B,? extends CoF>,FT extends Functor<T,? extends CoF>,PAFB extends Profunctor<A,FB,? extends CoP>,PSFT extends Profunctor<S,FT,? extends CoP>> PSFT` | `apply(PAFB pafb)` The polymorphic arrow between profunctors in this optic interface.
    `default <R,U> ProtoOptic<P,R,U,A,B>` | `compose(ProtoOptic<? super P,R,U,S,T> g)` Right-to-Left composition of proto-optics.
    `default <C> ProtoOptic<P,S,T,C,B>` | `mapA(Fn1<? super A,? extends C> fn)` Covariantly map `A` to `C`, yielding a new optic.
    `default <Z> ProtoOptic<P,S,T,A,Z>` | `mapB(Fn1<? super Z,? extends B> fn)` Contravariantly map `B` to `Z`, yielding a new optic.
    `default <R> ProtoOptic<P,R,T,A,B>` | `mapS(Fn1<? super R,? extends S> fn)` Contravariantly map `S` to `R`, yielding a new optic.
    `default <U> ProtoOptic<P,S,U,A,B>` | `mapT(Fn1<? super T,? extends U> fn)` Covariantly map `T` to `U`, yielding a new optic.
    `<F extends Applicative<?,F>> Optic<P,F,S,T,A,B>` | `toOptic(Pure<F> pure)` Given a `Pure` lifting function, fix this `ProtoOptic` to the given `Functor` and promote it to an `Optic`.

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

      `andThen, compose, monomorphize, optic, reframe`

- - ### Method Detail

    - #### toOptic

          <F extends Applicative<?,F>> Optic<P,F,S,T,A,B> toOptic(Pure<F> pure)

      Given a `Pure` lifting function, fix this `ProtoOptic` to the given `Functor` and promote it to an `Optic`.
      Type Parameters:
        `F` - the `Functor` bound
      Parameters:
        `pure` - the `Pure` lifting function
      Returns:
        the `Optic`

    - #### apply

          default <CoP extends Profunctor<?,?,? extends P>,CoF extends Functor<?,? extends Identity<?>>,FB extends Functor<B,? extends CoF>,FT extends Functor<T,? extends CoF>,PAFB extends Profunctor<A,FB,? extends CoP>,PSFT extends Profunctor<S,FT,? extends CoP>> PSFT apply(PAFB pafb)

      The polymorphic arrow between profunctors in this optic interface.
      Specified by:
        `apply` in interface `Optic<P extends Profunctor<?,?,? extends P>,Identity<?>,S,T,A,B>`
      Type Parameters:
        `CoP` - the profunctor type constraint witnessed by the application of this optic
        `CoF` - the functor type constraint witnessed by the application of this optic
        `FB` - the covariant parameter type of the input profunctor
        `FT` - the covariant parameter type of the output profunctor
        `PAFB` - the full input type
        `PSFT` - the full output type
      Parameters:
        `pafb` - the input
      Returns:
        the output profunctor

    - #### andThen

          default <Z,C> ProtoOptic<P,S,T,Z,C> andThen(ProtoOptic<? super P,A,B,Z,C> f)

      Left-to-right composition of proto-optics. Requires compatibility between `S` and `T`.
      Type Parameters:
        `Z` - the new left side of the input profunctor
        `C` - the new right side's functor embedding of the input profunctor
      Parameters:
        `f` - the other proto-optic
      Returns:
        the composed proto-optic

    - #### compose

          default <R,U> ProtoOptic<P,R,U,A,B> compose(ProtoOptic<? super P,R,U,S,T> g)

      Right-to-Left composition of proto-optics. Requires compatibility between `A` and `B`.
      Type Parameters:
        `R` - the new left side of the output profunctor
        `U` - the new right side's functor embedding of the output profunctor
      Parameters:
        `g` - the other proto-optic
      Returns:
        the composed proto-optic

    - #### mapS

          default <R> ProtoOptic<P,R,T,A,B> mapS(Fn1<? super R,? extends S> fn)

      Contravariantly map `S` to `R`, yielding a new optic.
      Specified by:
        `mapS` in interface `Optic<P extends Profunctor<?,?,? extends P>,Identity<?>,S,T,A,B>`
      Type Parameters:
        `R` - the new left side of the output profunctor
      Parameters:
        `fn` - the mapping function
      Returns:
        the new optic

    - #### mapT

          default <U> ProtoOptic<P,S,U,A,B> mapT(Fn1<? super T,? extends U> fn)

      Covariantly map `T` to `U`, yielding a new optic.
      Specified by:
        `mapT` in interface `Optic<P extends Profunctor<?,?,? extends P>,Identity<?>,S,T,A,B>`
      Type Parameters:
        `U` - the new right side's functor embedding of the output profunctor
      Parameters:
        `fn` - the mapping function
      Returns:
        the new optic

    - #### mapA

          default <C> ProtoOptic<P,S,T,C,B> mapA(Fn1<? super A,? extends C> fn)

      Covariantly map `A` to `C`, yielding a new optic.
      Specified by:
        `mapA` in interface `Optic<P extends Profunctor<?,?,? extends P>,Identity<?>,S,T,A,B>`
      Type Parameters:
        `C` - the new left side of the input profunctor
      Parameters:
        `fn` - the mapping function
      Returns:
        the new optic

    - #### mapB

          default <Z> ProtoOptic<P,S,T,A,Z> mapB(Fn1<? super Z,? extends B> fn)

      Contravariantly map `B` to `Z`, yielding a new optic.
      Specified by:
        `mapB` in interface `Optic<P extends Profunctor<?,?,? extends P>,Identity<?>,S,T,A,B>`
      Type Parameters:
        `Z` - the new right side's functor embedding of the input profunctor
      Parameters:
        `fn` - the mapping function
      Returns:
        the new optic