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.
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    private final Fn1<? super B,? extends T>
     
    private final Fn1<? super S,? extends A>
     
  • Constructor Summary

    Constructors
    Constructor
    Description
    Exchange(Fn1<? super S,? extends A> sa, Fn1<? super B,? extends T> bt)
     
  • Method Summary

    Modifier and Type
    Method
    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
  • Field Details

    • sa

      private final Fn1<? super S,? extends A> sa
    • bt

      private final Fn1<? super B,? extends T> bt
  • Constructor Details

    • Exchange

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

    • 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<A,B,S>
      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<A,B,S>
      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<A,B,S>
      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<A,B>
      Specified by:
      contraMap in interface Profunctor<A,B,S>
      Type Parameters:
      Z - the new parameter type
      Parameters:
      fn - the mapping function
      Returns:
      the mapped Contravariant functor instance