com.jnape.palatable.lambda.functor.builtin

## Class Exchange<A,B,S,T>

- java.lang.Object
- - com.jnape.palatable.lambda.functor.builtin.Exchange<A,B,S,T>

- Type Parameters:
    `A` - the smaller viewed value of an `Iso`
    `B` - the smaller viewing value of an `Iso`
    `S` - the larger viewing value of an `Iso`
    `T` - the larger viewed value of an `Iso`
  All Implemented Interfaces:
    Contravariant<S,Profunctor<?,T,Exchange<A,B,?,?>>>, Profunctor<S,T,Exchange<A,B,?,?>>

      public final class Exchange<A,B,S,T>
      extends Object
      implements Profunctor<S,T,Exchange<A,B,?,?>>

  A profunctor used to extract the isomorphic functions an `Iso` is composed of.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `Exchange(Fn1<? super S,? extends A> sa, Fn1<? super B,? extends T> bt)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `Fn1<? super B,? extends T>` | `bt()` Extract the mapping `B -> T`.
    `<Z> Exchange<A,B,Z,T>` | `contraMap(Fn1<? super Z,? extends S> fn)` Contravariantly map `A <- B`.
    `<Z,C> Exchange<A,B,Z,C>` | `diMap(Fn1<? super Z,? extends S> lFn, Fn1<? super T,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Z> Exchange<A,B,Z,T>` | `diMapL(Fn1<? super Z,? extends S> fn)` Contravariantly map over the left parameter.
    `<C> Exchange<A,B,S,C>` | `diMapR(Fn1<? super T,? extends C> fn)` Covariantly map over the right parameter.
    `Fn1<? super S,? extends A>` | `sa()` Extract the mapping `S -> A`.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### Exchange

          public Exchange(Fn1<? super S,? extends A> sa,
                          Fn1<? super B,? extends T> bt)

  - ### Method Detail

    - #### sa

          public Fn1<? super S,? extends A> sa()

      Extract the mapping `S -> A`.
      Returns:
        an ``Fn1`<S, A>`

    - #### bt

          public Fn1<? super B,? extends T> bt()

      Extract the mapping `B -> T`.
      Returns:
        an ``Fn1`<B, T>`

    - #### diMap

          public <Z,C> Exchange<A,B,Z,C> diMap(Fn1<? super Z,? extends S> lFn,
                                               Fn1<? super T,? extends C> rFn)

      Dually map contravariantly over the left parameter and covariantly over the right parameter. This is isomorphic to `diMapL(lFn).diMapR(rFn)`.
      Specified by:
        `diMap` in interface `Profunctor<S,T,Exchange<A,B,?,?>>`
      Type Parameters:
        `Z` - the new left parameter type
        `C` - the new right parameter type
      Parameters:
        `lFn` - the left parameter mapping function
        `rFn` - the right parameter mapping function
      Returns:
        a profunctor over Z (the new left parameter type) and C (the new right parameter type)

    - #### diMapL

          public <Z> Exchange<A,B,Z,T> diMapL(Fn1<? super Z,? extends S> fn)

      Contravariantly map over the left parameter.
      Specified by:
        `diMapL` in interface `Profunctor<S,T,Exchange<A,B,?,?>>`
      Type Parameters:
        `Z` - the new left parameter type
      Parameters:
        `fn` - the mapping function
      Returns:
        a profunctor over Z (the new left parameter type) and C (the same right parameter type)

    - #### diMapR

          public <C> Exchange<A,B,S,C> diMapR(Fn1<? super T,? extends C> fn)

      Covariantly map over the right parameter. For all profunctors that are also functors, it should hold that `diMapR(f) == fmap(f)`.
      Specified by:
        `diMapR` in interface `Profunctor<S,T,Exchange<A,B,?,?>>`
      Type Parameters:
        `C` - the new right parameter type
      Parameters:
        `fn` - the mapping function
      Returns:
        a profunctor over A (the same left parameter type) and C (the new right parameter type)

    - #### contraMap

          public <Z> Exchange<A,B,Z,T> contraMap(Fn1<? super Z,? extends S> fn)

      Contravariantly map `A <- B`.
      Specified by:
        `contraMap` in interface `Contravariant<S,Profunctor<?,T,Exchange<A,B,?,?>>>`
      Specified by:
        `contraMap` in interface `Profunctor<S,T,Exchange<A,B,?,?>>`
      Type Parameters:
        `Z` - the new parameter type
      Parameters:
        `fn` - the mapping function
      Returns:
        the mapped Contravariant functor instance