## Uses of Class
com.jnape.palatable.lambda.adt.choice.Choice8

- Packages that use Choice8
  Package | Description
  --- | ---
  com.jnape.palatable.lambda.adt.choice |

- - ### Uses of Choice8 in com.jnape.palatable.lambda.adt.choice

    Methods in com.jnape.palatable.lambda.adt.choice with type parameters of type Choice8
    Modifier and Type | Method and Description
    --- | ---
    `<I,App extends Applicative<?,App>,TravB extends Traversable<I,Choice8<A,B,C,D,E,F,G,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice8.`traverse(Fn1<? super H,? extends Applicative<I,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.

    Methods in com.jnape.palatable.lambda.adt.choice that return Choice8
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D,E,F,G,H> Choice8<A,B,C,D,E,F,G,H>` | Choice8.`a(A a)` Static factory method for wrapping a value of type `A` in a `Choice8`.
    `static <A,B,C,D,E,F,G,H> Choice8<A,B,C,D,E,F,G,H>` | Choice8.`b(B b)` Static factory method for wrapping a value of type `B` in a `Choice8`.
    `<I,J> Choice8<A,B,C,D,E,F,I,J>` | Choice8.`biMap(Fn1<? super G,? extends I> lFn, Fn1<? super H,? extends J> rFn)` Dually map covariantly over both the left and right parameters.
    `<I> Choice8<A,B,C,D,E,F,I,H>` | Choice8.`biMapL(Fn1<? super G,? extends I> fn)` Covariantly map over the left parameter.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`biMapR(Fn1<? super H,? extends I> fn)` Covariantly map over the right parameter.
    `static <A,B,C,D,E,F,G,H> Choice8<A,B,C,D,E,F,G,H>` | Choice8.`c(C c)` Static factory method for wrapping a value of type `C` in a `Choice8`.
    `static <A,B,C,D,E,F,G,H> Choice8<A,B,C,D,E,F,G,H>` | Choice8.`d(D d)` Static factory method for wrapping a value of type `D` in a `Choice8`.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`discardL(Applicative<I,Choice8<A,B,C,D,E,F,G,?>> appB)` Sequence both this `Applicative` and `appB`, discarding this `Applicative's` result and returning `appB`.
    `<I> Choice8<A,B,C,D,E,F,G,H>` | Choice8.`discardR(Applicative<I,Choice8<A,B,C,D,E,F,G,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `<H> Choice8<A,B,C,D,E,F,G,H>` | Choice7.`diverge()` Diverge this coproduct by introducing another possible type that it could represent.
    `static <A,B,C,D,E,F,G,H> Choice8<A,B,C,D,E,F,G,H>` | Choice8.`e(E e)` Static factory method for wrapping a value of type `E` in a `Choice8`.
    `static <A,B,C,D,E,F,G,H> Choice8<A,B,C,D,E,F,G,H>` | Choice8.`f(F f)` Static factory method for wrapping a value of type `F` in a `Choice8`.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`flatMap(Fn1<? super H,? extends Monad<I,Choice8<A,B,C,D,E,F,G,?>>> fn)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`fmap(Fn1<? super H,? extends I> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `static <A,B,C,D,E,F,G,H> Choice8<A,B,C,D,E,F,G,H>` | Choice8.`g(G g)` Static factory method for wrapping a value of type `G` in a `Choice8`.
    `static <A,B,C,D,E,F,G,H> Choice8<A,B,C,D,E,F,G,H>` | Choice8.`h(H h)` Static factory method for wrapping a value of type `H` in a `Choice8`.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`pure(I i)` Lift the value `b` into this applicative functor.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`trampolineM(Fn1<? super H,? extends MonadRec<RecursiveResult<H,I>,Choice8<A,B,C,D,E,F,G,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`zip(Applicative<Fn1<? super H,? extends I>,Choice8<A,B,C,D,E,F,G,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

    Methods in com.jnape.palatable.lambda.adt.choice that return types with arguments of type Choice8
    Modifier and Type | Method and Description
    --- | ---
    `<I> Lazy<Choice8<A,B,C,D,E,F,G,I>>` | Choice8.`lazyZip(Lazy<? extends Applicative<Fn1<? super H,? extends I>,Choice8<A,B,C,D,E,F,G,?>>> lazyAppFn)` Given a `lazy` instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `static <A,B,C,D,E,F,G> Pure<Choice8<A,B,C,D,E,F,G,?>>` | Choice8.`pureChoice()` The canonical `Pure` instance for `Choice8`.

    Method parameters in com.jnape.palatable.lambda.adt.choice with type arguments of type Choice8
    Modifier and Type | Method and Description
    --- | ---
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`discardL(Applicative<I,Choice8<A,B,C,D,E,F,G,?>> appB)` Sequence both this `Applicative` and `appB`, discarding this `Applicative's` result and returning `appB`.
    `<I> Choice8<A,B,C,D,E,F,G,H>` | Choice8.`discardR(Applicative<I,Choice8<A,B,C,D,E,F,G,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`flatMap(Fn1<? super H,? extends Monad<I,Choice8<A,B,C,D,E,F,G,?>>> fn)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<I> Lazy<Choice8<A,B,C,D,E,F,G,I>>` | Choice8.`lazyZip(Lazy<? extends Applicative<Fn1<? super H,? extends I>,Choice8<A,B,C,D,E,F,G,?>>> lazyAppFn)` Given a `lazy` instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`trampolineM(Fn1<? super H,? extends MonadRec<RecursiveResult<H,I>,Choice8<A,B,C,D,E,F,G,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`zip(Applicative<Fn1<? super H,? extends I>,Choice8<A,B,C,D,E,F,G,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.