com.jnape.palatable.lambda.functor

## Interface Cocartesian<A,B,P extends Cocartesian<?,?,P>>

- Type Parameters:
    `A` - the type of the left parameter
    `B` - the type of the left parameter
    `P` - the unification parameter
  All Superinterfaces:
    Contravariant<A,Profunctor<?,B,P>>, Profunctor<A,B,P>
  All Known Subinterfaces:
    BiMonoidFactory<A,B,C>, BiPredicate<A,B>, BiSemigroupFactory<A,B,C>, Effect<A>, Fn0<A>, Fn1<A,B>, Fn2<A,B,C>, Fn3<A,B,C,D>, Fn4<A,B,C,D,E>, Fn5<A,B,C,D,E,F>, Fn6<A,B,C,D,E,F,G>, Fn7<A,B,C,D,E,F,G,H>, Fn8<A,B,C,D,E,F,G,H,I>, Kleisli<A,B,M,MB>, Monoid<A>, MonoidFactory<A,B>, Predicate<A>, Semigroup<A>, SemigroupFactory<A,B>
  All Known Implementing Classes:
    Absent, AddAll, All, Alter, And, Any, AutoBracket, Between, Both, Bracket, CartesianProduct, CatMaybes, Clamp, CmpEq, CmpEqBy, Coalesce, Collapse, Collapse, Compose, Compose, Concat, Cons, Constantly, Cycle, Difference, Distinct, Downcast, Drop, DropWhile, Empty, Endo, EndoK, Eq, Filter, Find, First, Flatten, FoldLeft, FoldRight, Force, GroupBy, GT, GTBy, GTE, GTEBy, Head, Id, IfThenElse, InGroupsOf, Init, Inits, Intersection, Intersperse, Into, Into1, Into3, Into4, Into5, Into6, Into7, Into8, Iterate, Join, Last, Last, LazyRec, LeftAll, LeftAll, LeftAny, LeftAny, LiftA2, LiftA3, LiftA4, LiftA5, LiftA6, LiftA7, LT, LTBy, LTE, LTEBy, Magnetize, MagnetizeBy, Map, Market, Matching, Max, MaxBy, Merge, Merge, MergeMaps, Min, MinBy, Not, Occurrences, Or, Over, Partition, Peek, Peek2, Pre, PrependAll, Present, PutAll, RateLimit, Re, ReduceLeft, ReduceRight, Repeat, Replicate, Reverse, RightAll, RightAll, RightAny, RightAny, RunAll, RunAll, ScanLeft, Sequence, Set, Size, Slide, Snoc, Sort, SortBy, SortWith, Span, Tagged, Tail, Tails, Take, TakeWhile, Times, ToArray, ToCollection, ToMap, Trampoline, Trivial, Tupler2, Uncons, Under, Unfoldr, Union, Until, Upcast, View, Xor, Zip, ZipWith

      public interface Cocartesian<A,B,P extends Cocartesian<?,?,P>>
      extends Profunctor<A,B,P>

  `Profunctor` strength in the cocartesian coproduct sense: `p a b -> p (c v a) (c v b)` for any type `c`.
  See Also:
    `Fn1`, `Cartesian`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default Cocartesian<A,Choice2<A,B>,P>` | `choose()` Choose between the covariantly-positioned carrier type and the contravariantly-positioned carrier type.
    `<C> Cocartesian<Choice2<C,A>,Choice2<C,B>,P>` | `cocartesian()` Choose some type `C` or this profunctor's carrier types.
    `default <Z> Cocartesian<Z,B,P>` | `contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `<Z,C> Cocartesian<Z,C,P>` | `diMap(Fn1<? super Z,? extends A> lFn, Fn1<? super B,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `default <Z> Cocartesian<Z,B,P>` | `diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the left parameter.
    `default <C> Cocartesian<A,C,P>` | `diMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.

- - ### Method Detail

    - #### cocartesian

          <C> Cocartesian<Choice2<C,A>,Choice2<C,B>,P> cocartesian()

      Choose some type `C` or this profunctor's carrier types.
      Type Parameters:
        `C` - the choice type
      Returns:
        the cocartesian-costrengthened profunctor

    - #### choose

          default Cocartesian<A,Choice2<A,B>,P> choose()

      Choose between the covariantly-positioned carrier type and the contravariantly-positioned carrier type. This can be used to encode partial functions `a -> (_|_ v b)` as total functions `a -> (a v b)`.
      Returns:
        the profunctor with a choice

    - #### diMap

          <Z,C> Cocartesian<Z,C,P> diMap(Fn1<? super Z,? extends A> lFn,
                                         Fn1<? super B,? 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,P extends Cocartesian<?,?,P>>`
      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

          default <Z> Cocartesian<Z,B,P> diMapL(Fn1<? super Z,? extends A> fn)

      Contravariantly map over the left parameter.
      Specified by:
        `diMapL` in interface `Profunctor<A,B,P extends Cocartesian<?,?,P>>`
      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

          default <C> Cocartesian<A,C,P> diMapR(Fn1<? super B,? 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,P extends Cocartesian<?,?,P>>`
      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

          default <Z> Cocartesian<Z,B,P> contraMap(Fn1<? super Z,? extends A> fn)

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