## Uses of Class
com.jnape.palatable.lambda.functor.builtin.Lazy

- Packages that use Lazy
  Package | Description
  --- | ---
  com.jnape.palatable.lambda.adt |
  com.jnape.palatable.lambda.adt.choice |
  com.jnape.palatable.lambda.adt.hlist |
  com.jnape.palatable.lambda.functions |
  com.jnape.palatable.lambda.functions.builtin.fn2 |
  com.jnape.palatable.lambda.functions.builtin.fn3 |
  com.jnape.palatable.lambda.functor |
  com.jnape.palatable.lambda.functor.builtin |
  com.jnape.palatable.lambda.io |
  com.jnape.palatable.lambda.monad |
  com.jnape.palatable.lambda.monad.transformer |
  com.jnape.palatable.lambda.monad.transformer.builtin |
  com.jnape.palatable.lambda.monoid |
  com.jnape.palatable.lambda.optics |
  com.jnape.palatable.lambda.semigroup |
  com.jnape.palatable.lambda.traversable |

- - ### Uses of Lazy in com.jnape.palatable.lambda.adt

    Methods in com.jnape.palatable.lambda.adt that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<Maybe<B>>` | Maybe.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Maybe<?>>> lazyAppFn)` Terminate early if this is a `Nothing`; otherwise, continue the `zip`.
    `<B> Lazy<Try<B>>` | Try.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Try<?>>> 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.
    `<C> Lazy<These<A,C>>` | These.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,These<A,?>>> 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.
    `<R2> Lazy<Either<L,R2>>` | Either.`lazyZip(Lazy<? extends Applicative<Fn1<? super R,? extends R2>,Either<L,?>>> 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.

    Methods in com.jnape.palatable.lambda.adt with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<Maybe<B>>` | Maybe.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Maybe<?>>> lazyAppFn)` Terminate early if this is a `Nothing`; otherwise, continue the `zip`.
    `<B> Lazy<Try<B>>` | Try.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Try<?>>> 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.
    `<C> Lazy<These<A,C>>` | These.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,These<A,?>>> 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.
    `<R2> Lazy<Either<L,R2>>` | Either.`lazyZip(Lazy<? extends Applicative<Fn1<? super R,? extends R2>,Either<L,?>>> 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.

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

    Methods in com.jnape.palatable.lambda.adt.choice that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<C> Lazy<Choice2<A,C>>` | Choice2.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Choice2<A,?>>> 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.
    `<D> Lazy<Choice3<A,B,D>>` | Choice3.`lazyZip(Lazy<? extends Applicative<Fn1<? super C,? extends D>,Choice3<A,B,?>>> 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.
    `<E> Lazy<Choice4<A,B,C,E>>` | Choice4.`lazyZip(Lazy<? extends Applicative<Fn1<? super D,? extends E>,Choice4<A,B,C,?>>> 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.
    `<F> Lazy<Choice5<A,B,C,D,F>>` | Choice5.`lazyZip(Lazy<? extends Applicative<Fn1<? super E,? extends F>,Choice5<A,B,C,D,?>>> 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.
    `<G> Lazy<Choice6<A,B,C,D,E,G>>` | Choice6.`lazyZip(Lazy<? extends Applicative<Fn1<? super F,? extends G>,Choice6<A,B,C,D,E,?>>> 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.
    `<H> Lazy<Choice7<A,B,C,D,E,F,H>>` | Choice7.`lazyZip(Lazy<? extends Applicative<Fn1<? super G,? extends H>,Choice7<A,B,C,D,E,F,?>>> 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> 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.

    Methods in com.jnape.palatable.lambda.adt.choice with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<C> Lazy<Choice2<A,C>>` | Choice2.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Choice2<A,?>>> 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.
    `<D> Lazy<Choice3<A,B,D>>` | Choice3.`lazyZip(Lazy<? extends Applicative<Fn1<? super C,? extends D>,Choice3<A,B,?>>> 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.
    `<E> Lazy<Choice4<A,B,C,E>>` | Choice4.`lazyZip(Lazy<? extends Applicative<Fn1<? super D,? extends E>,Choice4<A,B,C,?>>> 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.
    `<F> Lazy<Choice5<A,B,C,D,F>>` | Choice5.`lazyZip(Lazy<? extends Applicative<Fn1<? super E,? extends F>,Choice5<A,B,C,D,?>>> 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.
    `<G> Lazy<Choice6<A,B,C,D,E,G>>` | Choice6.`lazyZip(Lazy<? extends Applicative<Fn1<? super F,? extends G>,Choice6<A,B,C,D,E,?>>> 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.
    `<H> Lazy<Choice7<A,B,C,D,E,F,H>>` | Choice7.`lazyZip(Lazy<? extends Applicative<Fn1<? super G,? extends H>,Choice7<A,B,C,D,E,F,?>>> 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> 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.

  - ### Uses of Lazy in com.jnape.palatable.lambda.adt.hlist

    Methods in com.jnape.palatable.lambda.adt.hlist that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<_1Prime> Lazy<SingletonHList<_1Prime>>` | SingletonHList.`lazyZip(Lazy<? extends Applicative<Fn1<? super _1,? extends _1Prime>,SingletonHList<?>>> 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.
    `<_2Prime> Lazy<Tuple2<_1,_2Prime>>` | Tuple2.`lazyZip(Lazy<? extends Applicative<Fn1<? super _2,? extends _2Prime>,Tuple2<_1,?>>> 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.
    `<_3Prime> Lazy<Tuple3<_1,_2,_3Prime>>` | Tuple3.`lazyZip(Lazy<? extends Applicative<Fn1<? super _3,? extends _3Prime>,Tuple3<_1,_2,?>>> 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.
    `<_4Prime> Lazy<Tuple4<_1,_2,_3,_4Prime>>` | Tuple4.`lazyZip(Lazy<? extends Applicative<Fn1<? super _4,? extends _4Prime>,Tuple4<_1,_2,_3,?>>> 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.
    `<_5Prime> Lazy<Tuple5<_1,_2,_3,_4,_5Prime>>` | Tuple5.`lazyZip(Lazy<? extends Applicative<Fn1<? super _5,? extends _5Prime>,Tuple5<_1,_2,_3,_4,?>>> 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.
    `<_6Prime> Lazy<Tuple6<_1,_2,_3,_4,_5,_6Prime>>` | Tuple6.`lazyZip(Lazy<? extends Applicative<Fn1<? super _6,? extends _6Prime>,Tuple6<_1,_2,_3,_4,_5,?>>> 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.
    `<_7Prime> Lazy<Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>>` | Tuple7.`lazyZip(Lazy<? extends Applicative<Fn1<? super _7,? extends _7Prime>,Tuple7<_1,_2,_3,_4,_5,_6,?>>> 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.
    `<_8Prime> Lazy<Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>>` | Tuple8.`lazyZip(Lazy<? extends Applicative<Fn1<? super _8,? extends _8Prime>,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>> 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.

    Methods in com.jnape.palatable.lambda.adt.hlist with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<_1Prime> Lazy<SingletonHList<_1Prime>>` | SingletonHList.`lazyZip(Lazy<? extends Applicative<Fn1<? super _1,? extends _1Prime>,SingletonHList<?>>> 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.
    `<_2Prime> Lazy<Tuple2<_1,_2Prime>>` | Tuple2.`lazyZip(Lazy<? extends Applicative<Fn1<? super _2,? extends _2Prime>,Tuple2<_1,?>>> 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.
    `<_3Prime> Lazy<Tuple3<_1,_2,_3Prime>>` | Tuple3.`lazyZip(Lazy<? extends Applicative<Fn1<? super _3,? extends _3Prime>,Tuple3<_1,_2,?>>> 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.
    `<_4Prime> Lazy<Tuple4<_1,_2,_3,_4Prime>>` | Tuple4.`lazyZip(Lazy<? extends Applicative<Fn1<? super _4,? extends _4Prime>,Tuple4<_1,_2,_3,?>>> 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.
    `<_5Prime> Lazy<Tuple5<_1,_2,_3,_4,_5Prime>>` | Tuple5.`lazyZip(Lazy<? extends Applicative<Fn1<? super _5,? extends _5Prime>,Tuple5<_1,_2,_3,_4,?>>> 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.
    `<_6Prime> Lazy<Tuple6<_1,_2,_3,_4,_5,_6Prime>>` | Tuple6.`lazyZip(Lazy<? extends Applicative<Fn1<? super _6,? extends _6Prime>,Tuple6<_1,_2,_3,_4,_5,?>>> 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.
    `<_7Prime> Lazy<Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>>` | Tuple7.`lazyZip(Lazy<? extends Applicative<Fn1<? super _7,? extends _7Prime>,Tuple7<_1,_2,_3,_4,_5,_6,?>>> 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.
    `<_8Prime> Lazy<Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>>` | Tuple8.`lazyZip(Lazy<? extends Applicative<Fn1<? super _8,? extends _8Prime>,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>> 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.

  - ### Uses of Lazy in com.jnape.palatable.lambda.functions

    Methods in com.jnape.palatable.lambda.functions that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default <C> Lazy<Fn1<A,C>>` | Fn1.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Fn1<A,?>>> 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.

    Methods in com.jnape.palatable.lambda.functions with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default <C> Lazy<Fn1<A,C>>` | Fn1.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Fn1<A,?>>> 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.

  - ### Uses of Lazy in com.jnape.palatable.lambda.functions.builtin.fn2

    Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `Lazy<B>` | LazyRec.`checkedApply(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn, A a)`
    `static <A,B> Lazy<B>` | LazyRec.`lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn, A a)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return types with arguments of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B> Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>` | LazyRec.`lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn)`
    `static <A,B> Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>` | LazyRec.`lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn)`

    Method parameters in com.jnape.palatable.lambda.functions.builtin.fn2 with type arguments of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `Lazy<B>` | LazyRec.`checkedApply(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn, A a)`
    `Lazy<B>` | LazyRec.`checkedApply(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn, A a)`
    `Lazy<B>` | LazyRec.`checkedApply(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn, A a)`
    `static <A,B> Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>` | LazyRec.`lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn)`
    `static <A,B> Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>` | LazyRec.`lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn)`
    `static <A,B> Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>` | LazyRec.`lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn)`
    `static <A,B> Lazy<B>` | LazyRec.`lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn, A a)`
    `static <A,B> Lazy<B>` | LazyRec.`lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn, A a)`
    `static <A,B> Lazy<B>` | LazyRec.`lazyRec(Fn2<Kleisli<? super A,? extends B,Lazy<?>,Lazy<B>>,A,Lazy<B>> fn, A a)`

  - ### Uses of Lazy in com.jnape.palatable.lambda.functions.builtin.fn3

    Methods in com.jnape.palatable.lambda.functions.builtin.fn3 that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `Lazy<B>` | FoldRight.`checkedApply(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc, Iterable<A> as)`
    `static <A,B> Lazy<B>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc, Iterable<A> as)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn3 that return types with arguments of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B> Fn2<Lazy<B>,Iterable<A>,Lazy<B>>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn)`
    `static <A,B> Fn2<Lazy<B>,Iterable<A>,Lazy<B>>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn)`
    `static <A,B> Fn1<Iterable<A>,Lazy<B>>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn3 with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `Lazy<B>` | FoldRight.`checkedApply(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc, Iterable<A> as)`
    `static <A,B> Fn1<Iterable<A>,Lazy<B>>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc)`
    `static <A,B> Lazy<B>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc, Iterable<A> as)`

    Method parameters in com.jnape.palatable.lambda.functions.builtin.fn3 with type arguments of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `Lazy<B>` | FoldRight.`checkedApply(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc, Iterable<A> as)`
    `Lazy<B>` | FoldRight.`checkedApply(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc, Iterable<A> as)`
    `static <A,B> Fn2<Lazy<B>,Iterable<A>,Lazy<B>>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn)`
    `static <A,B> Fn2<Lazy<B>,Iterable<A>,Lazy<B>>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn)`
    `static <A,B> Fn1<Iterable<A>,Lazy<B>>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc)`
    `static <A,B> Fn1<Iterable<A>,Lazy<B>>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc)`
    `static <A,B> Lazy<B>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc, Iterable<A> as)`
    `static <A,B> Lazy<B>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc, Iterable<A> as)`

  - ### Uses of Lazy in com.jnape.palatable.lambda.functor

    Methods in com.jnape.palatable.lambda.functor that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Lazy<? extends Applicative<B,App>>` | Applicative.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,App>> 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.

    Methods in com.jnape.palatable.lambda.functor with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Lazy<? extends Applicative<B,App>>` | Applicative.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,App>> 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.

  - ### Uses of Lazy in com.jnape.palatable.lambda.functor.builtin

    Methods in com.jnape.palatable.lambda.functor.builtin with type parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,Lazy<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Lazy.`traverse(Fn1<? super A,? extends Applicative<B,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.functor.builtin that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<B>` | Lazy.`discardL(Applicative<B,Lazy<?>> appB)` Sequence both this `Applicative` and `appB`, discarding this `Applicative's` result and returning `appB`.
    `<B> Lazy<A>` | Lazy.`discardR(Applicative<B,Lazy<?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `<B> Lazy<B>` | Lazy.`flatMap(Fn1<? super A,? extends Monad<B,Lazy<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Lazy<B>` | Lazy.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `static <A> Lazy<A>` | Lazy.`lazy(A value)` Lift a pure value into a lazy computation.
    `static <A> Lazy<A>` | Lazy.`lazy(Fn0<A> fn0)` Wrap a computation in a lazy computation.
    `<B> Lazy<Compose<F,G,B>>` | Compose.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Compose<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.
    `<B> Lazy<Identity<B>>` | Identity.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Identity<?>>> 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.
    `<B> Lazy<State<S,B>>` | State.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,State<S,?>>> 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.
    `<B> Lazy<Writer<W,B>>` | Writer.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Writer<W,?>>> 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.
    `<C> Lazy<Const<A,C>>` | Const.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Const<A,?>>> 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.
    `<B> Lazy<B>` | Lazy.`pure(B b)` Lift the value `b` into this applicative functor.
    `<B> Lazy<B>` | Lazy.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Lazy<?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> Lazy<B>` | Lazy.`zip(Applicative<Fn1<? super A,? extends B>,Lazy<?>> 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.functor.builtin that return types with arguments of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `static Pure<Lazy<?>>` | Lazy.`pureLazy()` The canonical `Pure` instance for `Lazy`.

    Methods in com.jnape.palatable.lambda.functor.builtin with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<Compose<F,G,B>>` | Compose.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Compose<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.
    `<B> Lazy<Identity<B>>` | Identity.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Identity<?>>> 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.
    `<B> Lazy<State<S,B>>` | State.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,State<S,?>>> 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.
    `<B> Lazy<Writer<W,B>>` | Writer.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Writer<W,?>>> 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.
    `<C> Lazy<Const<A,C>>` | Const.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Const<A,?>>> 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.

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

  - ### Uses of Lazy in com.jnape.palatable.lambda.io

    Methods in com.jnape.palatable.lambda.io that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<IO<B>>` | IO.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,IO<?>>> 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.

    Methods in com.jnape.palatable.lambda.io with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<IO<B>>` | IO.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,IO<?>>> 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.

  - ### Uses of Lazy in com.jnape.palatable.lambda.monad

    Methods in com.jnape.palatable.lambda.monad that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Lazy<? extends MonadError<E,B,M>>` | MonadError.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> 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.
    `default <B> Lazy<? extends Monad<B,M>>` | Monad.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> 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.
    `default <B> Lazy<? extends MonadRec<B,M>>` | MonadRec.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> 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.
    `default <B> Lazy<? extends MonadReader<R,B,MR>>` | MonadReader.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MR>> 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.
    `default <B> Lazy<? extends MonadWriter<W,B,MW>>` | MonadWriter.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MW>> 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.
    `<B> Lazy<SafeT<M,B>>` | SafeT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,SafeT<M,?>>> 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.

    Methods in com.jnape.palatable.lambda.monad with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Lazy<? extends MonadError<E,B,M>>` | MonadError.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> 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.
    `default <B> Lazy<? extends Monad<B,M>>` | Monad.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> 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.
    `default <B> Lazy<? extends MonadRec<B,M>>` | MonadRec.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> 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.
    `default <B> Lazy<? extends MonadReader<R,B,MR>>` | MonadReader.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MR>> 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.
    `default <B> Lazy<? extends MonadWriter<W,B,MW>>` | MonadWriter.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MW>> 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.
    `<B> Lazy<SafeT<M,B>>` | SafeT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,SafeT<M,?>>> 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.

  - ### Uses of Lazy in com.jnape.palatable.lambda.monad.transformer

    Methods in com.jnape.palatable.lambda.monad.transformer that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Lazy<? extends MonadT<M,B,MT,T>>` | MonadT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MT>> 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.

    Methods in com.jnape.palatable.lambda.monad.transformer with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Lazy<? extends MonadT<M,B,MT,T>>` | MonadT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MT>> 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.

  - ### Uses of Lazy in com.jnape.palatable.lambda.monad.transformer.builtin

    Methods in com.jnape.palatable.lambda.monad.transformer.builtin with type parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<MLA extends MonadRec<Lazy<A>,M>> MLA` | LazyT.`runLazyT()` Recover the full structure of the embedded `Monad`.

    Methods in com.jnape.palatable.lambda.monad.transformer.builtin that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<IdentityT<M,B>>` | IdentityT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,IdentityT<M,?>>> 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.
    `<B> Lazy<LazyT<M,B>>` | LazyT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,LazyT<M,?>>> 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.
    `<B> Lazy<MaybeT<M,B>>` | MaybeT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MaybeT<M,?>>> 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.
    `<B> Lazy<ReaderT<R,M,B>>` | ReaderT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,ReaderT<R,M,?>>> 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.
    `<B> Lazy<StateT<S,M,B>>` | StateT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,StateT<S,M,?>>> 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.
    `<B> Lazy<WriterT<W,M,B>>` | WriterT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,WriterT<W,M,?>>> 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.
    `<R2> Lazy<EitherT<M,L,R2>>` | EitherT.`lazyZip(Lazy<? extends Applicative<Fn1<? super R,? extends R2>,EitherT<M,L,?>>> 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.

    Methods in com.jnape.palatable.lambda.monad.transformer.builtin with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<IdentityT<M,B>>` | IdentityT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,IdentityT<M,?>>> 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.
    `<B> Lazy<LazyT<M,B>>` | LazyT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,LazyT<M,?>>> 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.
    `<B> Lazy<MaybeT<M,B>>` | MaybeT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MaybeT<M,?>>> 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.
    `<B> Lazy<ReaderT<R,M,B>>` | ReaderT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,ReaderT<R,M,?>>> 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.
    `<B> Lazy<StateT<S,M,B>>` | StateT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,StateT<S,M,?>>> 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.
    `<B> Lazy<WriterT<W,M,B>>` | WriterT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,WriterT<W,M,?>>> 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.
    `<R2> Lazy<EitherT<M,L,R2>>` | EitherT.`lazyZip(Lazy<? extends Applicative<Fn1<? super R,? extends R2>,EitherT<M,L,?>>> 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.

    Method parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `static <M extends MonadRec<?,M>,A> LazyT<M,A>` | LazyT.`lazyT(MonadRec<Lazy<A>,M> mla)` Static factory method for lifting a ``Monad`<`Lazy`<A>, M>` into a `LazyT`.

  - ### Uses of Lazy in com.jnape.palatable.lambda.monoid

    Methods in com.jnape.palatable.lambda.monoid that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default Lazy<A>` | Monoid.`foldRight(A a, Iterable<A> as)` Catamorphism under this semigroup using `FoldRight`, where the binary operator is this semigroup, and the starting accumulator is provided.

  - ### Uses of Lazy in com.jnape.palatable.lambda.optics

    Methods in com.jnape.palatable.lambda.optics that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default <U> Lazy<Prism<S,U,A,B>>` | Prism.`lazyZip(Lazy<? extends Applicative<Fn1<? super T,? extends U>,Prism<S,?,A,B>>> 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.

    Methods in com.jnape.palatable.lambda.optics with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default <U> Lazy<Prism<S,U,A,B>>` | Prism.`lazyZip(Lazy<? extends Applicative<Fn1<? super T,? extends U>,Prism<S,?,A,B>>> 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.

  - ### Uses of Lazy in com.jnape.palatable.lambda.semigroup

    Methods in com.jnape.palatable.lambda.semigroup that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `default Lazy<A>` | Semigroup.`foldRight(A a, Iterable<A> as)` Catamorphism under this semigroup using `FoldRight`, where the binary operator is this semigroup, and the starting accumulator is provided.

  - ### Uses of Lazy in com.jnape.palatable.lambda.traversable

    Methods in com.jnape.palatable.lambda.traversable that return Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<LambdaIterable<B>>` | LambdaIterable.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,LambdaIterable<?>>> 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.

    Methods in com.jnape.palatable.lambda.traversable with parameters of type Lazy
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<LambdaIterable<B>>` | LambdaIterable.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,LambdaIterable<?>>> 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.