## Uses of Class
com.jnape.palatable.lambda.adt.Maybe

- Packages that use Maybe
  Package | Description
  --- | ---
  com.jnape.palatable.lambda.adt |
  com.jnape.palatable.lambda.adt.choice |
  com.jnape.palatable.lambda.adt.coproduct |
  com.jnape.palatable.lambda.adt.hlist |
  com.jnape.palatable.lambda.adt.hmap |
  com.jnape.palatable.lambda.functions.builtin.fn1 |
  com.jnape.palatable.lambda.functions.builtin.fn2 |
  com.jnape.palatable.lambda.internal.iteration |
  com.jnape.palatable.lambda.monad.transformer.builtin |
  com.jnape.palatable.lambda.monoid.builtin |
  com.jnape.palatable.lambda.optics |
  com.jnape.palatable.lambda.optics.functions |
  com.jnape.palatable.lambda.optics.lenses |
  com.jnape.palatable.lambda.optics.prisms |
  com.jnape.palatable.lambda.semigroup.builtin |

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

    Methods in com.jnape.palatable.lambda.adt with type parameters of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,Maybe<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Maybe.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)`

    Methods in com.jnape.palatable.lambda.adt that return Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Maybe<A>` | Maybe.`catchError(Fn1<? super Unit,? extends Monad<A,Maybe<?>>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `<B> Maybe<B>` | Maybe.`discardL(Applicative<B,Maybe<?>> appB)` Sequence both this `Applicative` and `appB`, discarding this `Applicative's` result and returning `appB`.
    `<B> Maybe<A>` | Maybe.`discardR(Applicative<B,Maybe<?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `Maybe<A>` | Maybe.`filter(Fn1<? super A,? extends Boolean> predicate)` If this value is present and satisfies `predicate`, return `just` the value; otherwise, return `nothing`.
    `<B> Maybe<B>` | Maybe.`flatMap(Fn1<? super A,? extends Monad<B,Maybe<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Maybe<B>` | Maybe.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `static <A> Maybe<A>` | Maybe.`fromEither(Either<?,A> either)` Convenience static factory method for creating a `Maybe` from an `Either`.
    `static <A> Maybe<A>` | Maybe.`fromOptional(Optional<? extends A> optional)` Convenience static factory method for creating a `Maybe` from an `Optional`.
    `static <A> Maybe<A>` | Maybe.`just(A a)` Lift a non-null value into `Maybe`.
    `static <A> Maybe<A>` | Maybe.`maybe(A a)` Lift a potentially null value into `Maybe`.
    `static <A> Maybe<A>` | Maybe.`nothing()` Return nothing.
    `Maybe<A>` | Maybe.`peek(Fn1<? super A,? extends IO<?>> effect)` Deprecated. in favor of `matching` into an `IO` and explicitly running it
    `<B> Maybe<B>` | Maybe.`pure(B b)` Lift the value into the `Maybe` monad
    `Maybe<A>` | Maybe.`throwError(Unit unit)` Throw an error value of type `E` into the `monad`.
    `Maybe<R>` | Either.`toMaybe()` In the left case, returns a `nothing()`; otherwise, returns `maybe(A)` around the right value.
    `Maybe<A>` | Try.`toMaybe()` If this is a success, wrap the value in a `just(A)` and return it.
    `<B> Maybe<B>` | Maybe.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Maybe<?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> Maybe<B>` | Maybe.`zip(Applicative<Fn1<? super A,? extends B>,Maybe<?>> 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 that return types with arguments of type Maybe
    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`.
    `Tuple2<Maybe<Unit>,Maybe<A>>` | Maybe.`project()` Project this coproduct onto a product, such that the index in the product that corresponds to this coproduct's value is present, while the other indices are absent.
    `Tuple2<Maybe<Unit>,Maybe<A>>` | Maybe.`project()` Project this coproduct onto a product, such that the index in the product that corresponds to this coproduct's value is present, while the other indices are absent.
    `static Pure<Maybe<?>>` | Maybe.`pureMaybe()` The canonical `Pure` instance for `Maybe`.

    Methods in com.jnape.palatable.lambda.adt with parameters of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <L,R> Either<L,R>` | Either.`fromMaybe(Maybe<R> maybe, Fn0<L> leftFn0)` Convert a `Maybe`<R> into an `Either<L, R>`, supplying the left value from `leftFn` in the case of `nothing()`.

    Method parameters in com.jnape.palatable.lambda.adt with type arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Maybe<A>` | Maybe.`catchError(Fn1<? super Unit,? extends Monad<A,Maybe<?>>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `<B> Maybe<B>` | Maybe.`discardL(Applicative<B,Maybe<?>> appB)` Sequence both this `Applicative` and `appB`, discarding this `Applicative's` result and returning `appB`.
    `<B> Maybe<A>` | Maybe.`discardR(Applicative<B,Maybe<?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `<B> Maybe<B>` | Maybe.`flatMap(Fn1<? super A,? extends Monad<B,Maybe<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<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> Maybe<B>` | Maybe.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Maybe<?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> Maybe<B>` | Maybe.`zip(Applicative<Fn1<? super A,? extends B>,Maybe<?>> 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 Maybe in com.jnape.palatable.lambda.adt.choice

    Methods in com.jnape.palatable.lambda.adt.choice that return types with arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Tuple6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | Choice6.`project()` Specialize this choice's projection to a `Tuple6`.
    `Tuple6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | Choice6.`project()` Specialize this choice's projection to a `Tuple6`.
    `Tuple6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | Choice6.`project()` Specialize this choice's projection to a `Tuple6`.
    `Tuple6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | Choice6.`project()` Specialize this choice's projection to a `Tuple6`.
    `Tuple6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | Choice6.`project()` Specialize this choice's projection to a `Tuple6`.
    `Tuple6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | Choice6.`project()` Specialize this choice's projection to a `Tuple6`.
    `Tuple5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | Choice5.`project()` Specialize this choice's projection to a `Tuple5`.
    `Tuple5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | Choice5.`project()` Specialize this choice's projection to a `Tuple5`.
    `Tuple5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | Choice5.`project()` Specialize this choice's projection to a `Tuple5`.
    `Tuple5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | Choice5.`project()` Specialize this choice's projection to a `Tuple5`.
    `Tuple5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | Choice5.`project()` Specialize this choice's projection to a `Tuple5`.
    `Tuple7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | Choice7.`project()` Specialize this choice's projection to a `Tuple7`.
    `Tuple7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | Choice7.`project()` Specialize this choice's projection to a `Tuple7`.
    `Tuple7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | Choice7.`project()` Specialize this choice's projection to a `Tuple7`.
    `Tuple7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | Choice7.`project()` Specialize this choice's projection to a `Tuple7`.
    `Tuple7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | Choice7.`project()` Specialize this choice's projection to a `Tuple7`.
    `Tuple7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | Choice7.`project()` Specialize this choice's projection to a `Tuple7`.
    `Tuple7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | Choice7.`project()` Specialize this choice's projection to a `Tuple7`.
    `Tuple3<Maybe<A>,Maybe<B>,Maybe<C>>` | Choice3.`project()` Specialize this choice's projection to a `Tuple3`.
    `Tuple3<Maybe<A>,Maybe<B>,Maybe<C>>` | Choice3.`project()` Specialize this choice's projection to a `Tuple3`.
    `Tuple3<Maybe<A>,Maybe<B>,Maybe<C>>` | Choice3.`project()` Specialize this choice's projection to a `Tuple3`.
    `Tuple2<Maybe<A>,Maybe<B>>` | Choice2.`project()` Specialize this choice's projection to a `Tuple2`.
    `Tuple2<Maybe<A>,Maybe<B>>` | Choice2.`project()` Specialize this choice's projection to a `Tuple2`.
    `Tuple8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | Choice8.`project()` Specialize this choice's projection to a `Tuple8`.
    `Tuple8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | Choice8.`project()` Specialize this choice's projection to a `Tuple8`.
    `Tuple8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | Choice8.`project()` Specialize this choice's projection to a `Tuple8`.
    `Tuple8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | Choice8.`project()` Specialize this choice's projection to a `Tuple8`.
    `Tuple8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | Choice8.`project()` Specialize this choice's projection to a `Tuple8`.
    `Tuple8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | Choice8.`project()` Specialize this choice's projection to a `Tuple8`.
    `Tuple8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | Choice8.`project()` Specialize this choice's projection to a `Tuple8`.
    `Tuple8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | Choice8.`project()` Specialize this choice's projection to a `Tuple8`.
    `Tuple4<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>>` | Choice4.`project()` Specialize this choice's projection to a `Tuple4`.
    `Tuple4<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>>` | Choice4.`project()` Specialize this choice's projection to a `Tuple4`.
    `Tuple4<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>>` | Choice4.`project()` Specialize this choice's projection to a `Tuple4`.
    `Tuple4<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>>` | Choice4.`project()` Specialize this choice's projection to a `Tuple4`.

  - ### Uses of Maybe in com.jnape.palatable.lambda.adt.coproduct

    Methods in com.jnape.palatable.lambda.adt.coproduct that return Maybe
    Modifier and Type | Method and Description
    --- | ---
    `default Maybe<A>` | CoProduct4.`projectA()` Convenience method for projecting this coproduct onto a product and then extracting the first slot value.
    `default Maybe<A>` | CoProduct2.`projectA()` Convenience method for projecting this coproduct onto a product and then extracting the first slot value.
    `default Maybe<A>` | CoProduct3.`projectA()` Convenience method for projecting this coproduct onto a product and then extracting the first slot value.
    `default Maybe<A>` | CoProduct8.`projectA()` Convenience method for projecting this coproduct onto a product and then extracting the first slot value.
    `default Maybe<A>` | CoProduct5.`projectA()` Convenience method for projecting this coproduct onto a product and then extracting the first slot value.
    `default Maybe<A>` | CoProduct6.`projectA()` Convenience method for projecting this coproduct onto a product and then extracting the first slot value.
    `default Maybe<A>` | CoProduct7.`projectA()` Convenience method for projecting this coproduct onto a product and then extracting the first slot value.
    `default Maybe<B>` | CoProduct4.`projectB()` Convenience method for projecting this coproduct onto a product and then extracting the second slot value.
    `default Maybe<B>` | CoProduct2.`projectB()` Convenience method for projecting this coproduct onto a product and then extracting the second slot value.
    `default Maybe<B>` | CoProduct3.`projectB()` Convenience method for projecting this coproduct onto a product and then extracting the second slot value.
    `default Maybe<B>` | CoProduct8.`projectB()` Convenience method for projecting this coproduct onto a product and then extracting the second slot value.
    `default Maybe<B>` | CoProduct5.`projectB()` Convenience method for projecting this coproduct onto a product and then extracting the second slot value.
    `default Maybe<B>` | CoProduct6.`projectB()` Convenience method for projecting this coproduct onto a product and then extracting the second slot value.
    `default Maybe<B>` | CoProduct7.`projectB()` Convenience method for projecting this coproduct onto a product and then extracting the second slot value.
    `default Maybe<C>` | CoProduct4.`projectC()` Convenience method for projecting this coproduct onto a product and then extracting the third slot value.
    `default Maybe<C>` | CoProduct3.`projectC()` Convenience method for projecting this coproduct onto a product and then extracting the third slot value.
    `default Maybe<C>` | CoProduct8.`projectC()` Convenience method for projecting this coproduct onto a product and then extracting the third slot value.
    `default Maybe<C>` | CoProduct5.`projectC()` Convenience method for projecting this coproduct onto a product and then extracting the third slot value.
    `default Maybe<C>` | CoProduct6.`projectC()` Convenience method for projecting this coproduct onto a product and then extracting the third slot value.
    `default Maybe<C>` | CoProduct7.`projectC()` Convenience method for projecting this coproduct onto a product and then extracting the third slot value.
    `default Maybe<D>` | CoProduct4.`projectD()` Convenience method for projecting this coproduct onto a product and then extracting the fourth slot value.
    `default Maybe<D>` | CoProduct8.`projectD()` Convenience method for projecting this coproduct onto a product and then extracting the fourth slot value.
    `default Maybe<D>` | CoProduct5.`projectD()` Convenience method for projecting this coproduct onto a product and then extracting the fourth slot value.
    `default Maybe<D>` | CoProduct6.`projectD()` Convenience method for projecting this coproduct onto a product and then extracting the fourth slot value.
    `default Maybe<D>` | CoProduct7.`projectD()` Convenience method for projecting this coproduct onto a product and then extracting the fourth slot value.
    `default Maybe<E>` | CoProduct8.`projectE()` Convenience method for projecting this coproduct onto a product and then extracting the fifth slot value.
    `default Maybe<E>` | CoProduct5.`projectE()` Convenience method for projecting this coproduct onto a product and then extracting the fifth slot value.
    `default Maybe<E>` | CoProduct6.`projectE()` Convenience method for projecting this coproduct onto a product and then extracting the fifth slot value.
    `default Maybe<E>` | CoProduct7.`projectE()` Convenience method for projecting this coproduct onto a product and then extracting the fifth slot value.
    `default Maybe<F>` | CoProduct8.`projectF()` Convenience method for projecting this coproduct onto a product and then extracting the sixth slot value.
    `default Maybe<F>` | CoProduct6.`projectF()` Convenience method for projecting this coproduct onto a product and then extracting the sixth slot value.
    `default Maybe<F>` | CoProduct7.`projectF()` Convenience method for projecting this coproduct onto a product and then extracting the sixth slot value.
    `default Maybe<G>` | CoProduct8.`projectG()` Convenience method for projecting this coproduct onto a product and then extracting the seventh slot value.
    `default Maybe<G>` | CoProduct7.`projectG()` Convenience method for projecting this coproduct onto a product and then extracting the seventh slot value.
    `default Maybe<H>` | CoProduct8.`projectH()` Convenience method for projecting this coproduct onto a product and then extracting the eighth slot value.

    Methods in com.jnape.palatable.lambda.adt.coproduct that return types with arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `default Product4<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>>` | CoProduct4.`project()` Project this coproduct onto a product.
    `default Product4<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>>` | CoProduct4.`project()` Project this coproduct onto a product.
    `default Product4<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>>` | CoProduct4.`project()` Project this coproduct onto a product.
    `default Product4<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>>` | CoProduct4.`project()` Project this coproduct onto a product.
    `default Product2<Maybe<A>,Maybe<B>>` | CoProduct2.`project()` Project this coproduct onto a product, such that the index in the product that corresponds to this coproduct's value is present, while the other indices are absent.
    `default Product2<Maybe<A>,Maybe<B>>` | CoProduct2.`project()` Project this coproduct onto a product, such that the index in the product that corresponds to this coproduct's value is present, while the other indices are absent.
    `default Product3<Maybe<A>,Maybe<B>,Maybe<C>>` | CoProduct3.`project()` Project this coproduct onto a product.
    `default Product3<Maybe<A>,Maybe<B>,Maybe<C>>` | CoProduct3.`project()` Project this coproduct onto a product.
    `default Product3<Maybe<A>,Maybe<B>,Maybe<C>>` | CoProduct3.`project()` Project this coproduct onto a product.
    `default Product8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | CoProduct8.`project()` Project this coproduct onto a product.
    `default Product8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | CoProduct8.`project()` Project this coproduct onto a product.
    `default Product8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | CoProduct8.`project()` Project this coproduct onto a product.
    `default Product8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | CoProduct8.`project()` Project this coproduct onto a product.
    `default Product8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | CoProduct8.`project()` Project this coproduct onto a product.
    `default Product8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | CoProduct8.`project()` Project this coproduct onto a product.
    `default Product8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | CoProduct8.`project()` Project this coproduct onto a product.
    `default Product8<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>,Maybe<H>>` | CoProduct8.`project()` Project this coproduct onto a product.
    `default Product5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | CoProduct5.`project()` Project this coproduct onto a product.
    `default Product5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | CoProduct5.`project()` Project this coproduct onto a product.
    `default Product5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | CoProduct5.`project()` Project this coproduct onto a product.
    `default Product5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | CoProduct5.`project()` Project this coproduct onto a product.
    `default Product5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | CoProduct5.`project()` Project this coproduct onto a product.
    `default Product6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | CoProduct6.`project()` Project this coproduct onto a product.
    `default Product6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | CoProduct6.`project()` Project this coproduct onto a product.
    `default Product6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | CoProduct6.`project()` Project this coproduct onto a product.
    `default Product6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | CoProduct6.`project()` Project this coproduct onto a product.
    `default Product6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | CoProduct6.`project()` Project this coproduct onto a product.
    `default Product6<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>>` | CoProduct6.`project()` Project this coproduct onto a product.
    `default Product7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | CoProduct7.`project()` Project this coproduct onto a product.
    `default Product7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | CoProduct7.`project()` Project this coproduct onto a product.
    `default Product7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | CoProduct7.`project()` Project this coproduct onto a product.
    `default Product7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | CoProduct7.`project()` Project this coproduct onto a product.
    `default Product7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | CoProduct7.`project()` Project this coproduct onto a product.
    `default Product7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | CoProduct7.`project()` Project this coproduct onto a product.
    `default Product7<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>,Maybe<F>,Maybe<G>>` | CoProduct7.`project()` Project this coproduct onto a product.

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

    Methods in com.jnape.palatable.lambda.adt.hlist that return Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <A> Maybe<Tuple7<A,A,A,A,A,A,A>>` | Tuple7.`fromIterable(Iterable<A> as)` Return `just` the first seven elements from the given `Iterable`, or `nothing` if there are less than seven elements.
    `static <A> Maybe<Tuple4<A,A,A,A>>` | Tuple4.`fromIterable(Iterable<A> as)` Return `just` the first four elements from the given `Iterable`, or `nothing` if there are less than four elements.
    `static <A> Maybe<Tuple6<A,A,A,A,A,A>>` | Tuple6.`fromIterable(Iterable<A> as)` Return `just` the first six elements from the given `Iterable`, or `nothing` if there are less than six elements.
    `static <A> Maybe<Tuple5<A,A,A,A,A>>` | Tuple5.`fromIterable(Iterable<A> as)` Return `just` the first five elements from the given `Iterable`, or `nothing` if there are less than five elements.
    `static <A> Maybe<Tuple2<A,A>>` | Tuple2.`fromIterable(Iterable<A> as)` Return `just` the first two elements from the given `Iterable`, or `nothing` if there are less than two elements.
    `static <A> Maybe<Tuple8<A,A,A,A,A,A,A,A>>` | Tuple8.`fromIterable(Iterable<A> as)` Return `just` the first eight elements from the given `Iterable`, or `nothing` if there are less than eight elements.
    `static <A> Maybe<Tuple3<A,A,A>>` | Tuple3.`fromIterable(Iterable<A> as)` Return `just` the first three elements from the given `Iterable`, or `nothing` if there are less than three elements.

  - ### Uses of Maybe in com.jnape.palatable.lambda.adt.hmap

    Methods in com.jnape.palatable.lambda.adt.hmap that return Maybe
    Modifier and Type | Method and Description
    --- | ---
    `<A,B> Maybe<B>` | HMap.`get(TypeSafeKey<A,B> key)` Retrieve the value at this key.

  - ### Uses of Maybe in com.jnape.palatable.lambda.functions.builtin.fn1

    Methods in com.jnape.palatable.lambda.functions.builtin.fn1 that return Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Maybe<Tuple2<A,Iterable<A>>>` | Uncons.`checkedApply(Iterable<A> as)`
    `Maybe<A>` | Last.`checkedApply(Iterable<A> as)`
    `Maybe<A>` | Head.`checkedApply(Iterable<A> as)`
    `static <A> Maybe<A>` | Head.`head(Iterable<A> as)`
    `static <A> Maybe<A>` | Last.`last(Iterable<A> as)`
    `static <A> Maybe<Tuple2<A,Iterable<A>>>` | Uncons.`uncons(Iterable<A> as)`

    Method parameters in com.jnape.palatable.lambda.functions.builtin.fn1 with type arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <A> Iterable<A>` | CatMaybes.`catMaybes(Iterable<Maybe<A>> as)`
    `Iterable<A>` | CatMaybes.`checkedApply(Iterable<Maybe<A>> maybes)`

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

    Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Maybe<A>` | Find.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `Maybe<A>` | ReduceRight.`checkedApply(Fn2<? super A,? super A,? extends A> fn, Iterable<A> as)`
    `Maybe<A>` | ReduceLeft.`checkedApply(Fn2<? super A,? super A,? extends A> fn, Iterable<A> as)`
    `static <A> Maybe<A>` | Find.`find(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `static <A> Maybe<A>` | ReduceLeft.`reduceLeft(Fn2<? super A,? super A,? extends A> fn, Iterable<A> as)`
    `static <A> Maybe<A>` | ReduceRight.`reduceRight(Fn2<? super A,? super A,? extends A> fn, Iterable<A> as)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return types with arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <A> Fn1<Iterable<A>,Maybe<A>>` | Find.`find(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Fn1<Iterable<A>,Maybe<A>>` | ReduceLeft.`reduceLeft(Fn2<? super A,? super A,? extends A> fn)`
    `static <A> Fn1<Iterable<A>,Maybe<A>>` | ReduceRight.`reduceRight(Fn2<? super A,? super A,? extends A> fn)`

    Method parameters in com.jnape.palatable.lambda.functions.builtin.fn2 with type arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Iterable<A>` | Unfoldr.`checkedApply(Fn1<? super B,Maybe<Tuple2<A,B>>> fn, B b)`
    `static <A,B> Fn1<B,Iterable<A>>` | Unfoldr.`unfoldr(Fn1<? super B,Maybe<Tuple2<A,B>>> fn)`
    `static <A,B> Iterable<A>` | Unfoldr.`unfoldr(Fn1<? super B,Maybe<Tuple2<A,B>>> fn, B b)`

  - ### Uses of Maybe in com.jnape.palatable.lambda.internal.iteration

    Constructor parameters in com.jnape.palatable.lambda.internal.iteration with type arguments of type Maybe
    Constructor and Description
    `UnfoldingIterator(Fn1<? super B,Maybe<Tuple2<A,B>>> function, B seed)`

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

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

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

  - ### Uses of Maybe in com.jnape.palatable.lambda.monoid.builtin

    Methods in com.jnape.palatable.lambda.monoid.builtin that return Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Maybe<A>` | Last.`checkedApply(Maybe<A> x, Maybe<A> y)`
    `Maybe<A>` | First.`checkedApply(Maybe<A> x, Maybe<A> y)`
    `static <A> Maybe<A>` | First.`first(Maybe<A> x, Maybe<A> y)`
    `<B> Maybe<A>` | First.`foldMap(Fn1<? super B,? extends Maybe<A>> fn, Iterable<B> bs)`
    `Maybe<A>` | Last.`identity()`
    `Maybe<A>` | First.`identity()`
    `static <A> Maybe<A>` | Last.`last(Maybe<A> x, Maybe<A> y)`
    `static <A> Maybe<A>` | Present.`present(Semigroup<A> semigroup, Maybe<A> x, Maybe<A> y)`

    Methods in com.jnape.palatable.lambda.monoid.builtin that return types with arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Monoid<Maybe<A>>` | Present.`checkedApply(Semigroup<A> aSemigroup)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | First.`first(Maybe<A> x)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | First.`first(Maybe<A> x)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Last.`last(Maybe<A> x)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Last.`last(Maybe<A> x)`
    `static <A> Monoid<Maybe<A>>` | Present.`present(Semigroup<A> semigroup)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Present.`present(Semigroup<A> aSemigroup, Maybe<A> x)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Present.`present(Semigroup<A> aSemigroup, Maybe<A> x)`

    Methods in com.jnape.palatable.lambda.monoid.builtin with parameters of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Maybe<A>` | Last.`checkedApply(Maybe<A> x, Maybe<A> y)`
    `Maybe<A>` | Last.`checkedApply(Maybe<A> x, Maybe<A> y)`
    `Maybe<A>` | First.`checkedApply(Maybe<A> x, Maybe<A> y)`
    `Maybe<A>` | First.`checkedApply(Maybe<A> x, Maybe<A> y)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | First.`first(Maybe<A> x)`
    `static <A> Maybe<A>` | First.`first(Maybe<A> x, Maybe<A> y)`
    `static <A> Maybe<A>` | First.`first(Maybe<A> x, Maybe<A> y)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Last.`last(Maybe<A> x)`
    `static <A> Maybe<A>` | Last.`last(Maybe<A> x, Maybe<A> y)`
    `static <A> Maybe<A>` | Last.`last(Maybe<A> x, Maybe<A> y)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Present.`present(Semigroup<A> aSemigroup, Maybe<A> x)`
    `static <A> Maybe<A>` | Present.`present(Semigroup<A> semigroup, Maybe<A> x, Maybe<A> y)`
    `static <A> Maybe<A>` | Present.`present(Semigroup<A> semigroup, Maybe<A> x, Maybe<A> y)`

    Method parameters in com.jnape.palatable.lambda.monoid.builtin with type arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `<B> Maybe<A>` | First.`foldMap(Fn1<? super B,? extends Maybe<A>> fn, Iterable<B> bs)`

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

    Method parameters in com.jnape.palatable.lambda.optics with type arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <S,A> Prism.Simple<S,A>` | Prism.`simplePrism(Fn1<? super S,? extends Maybe<A>> sMaybeA, Fn1<? super A,? extends S> as)` Static factory method for creating a simple `Prism` from a function and its potentially failing inverse.

  - ### Uses of Maybe in com.jnape.palatable.lambda.optics.functions

    Methods in com.jnape.palatable.lambda.optics.functions that return types with arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Optic<P,Const<Maybe<A>,?>,S,T,Maybe<A>,B>` | Pre.`checkedApply(Optic<P,? super Const<Maybe<A>,?>,S,T,A,B> optic)`
    `Optic<P,Const<Maybe<A>,?>,S,T,Maybe<A>,B>` | Pre.`checkedApply(Optic<P,? super Const<Maybe<A>,?>,S,T,A,B> optic)`
    `static <P extends Profunctor<?,?,? extends P>,S,T,A,B> Optic<P,Const<Maybe<A>,?>,S,T,Maybe<A>,B>` | Pre.`pre(Optic<P,? super Const<Maybe<A>,?>,S,T,A,B> optic)`
    `static <P extends Profunctor<?,?,? extends P>,S,T,A,B> Optic<P,Const<Maybe<A>,?>,S,T,Maybe<A>,B>` | Pre.`pre(Optic<P,? super Const<Maybe<A>,?>,S,T,A,B> optic)`
    `static <P extends Profunctor<?,?,? extends P>,S,T,A,B> Optic<P,Const<Maybe<A>,?>,S,T,Maybe<A>,B>` | Pre.`pre(ProtoOptic<P,S,T,A,B> protoOptic)`
    `static <P extends Profunctor<?,?,? extends P>,S,T,A,B> Optic<P,Const<Maybe<A>,?>,S,T,Maybe<A>,B>` | Pre.`pre(ProtoOptic<P,S,T,A,B> protoOptic)`

    Method parameters in com.jnape.palatable.lambda.optics.functions with type arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `Optic<P,Const<Maybe<A>,?>,S,T,Maybe<A>,B>` | Pre.`checkedApply(Optic<P,? super Const<Maybe<A>,?>,S,T,A,B> optic)`
    `static <P extends Profunctor<?,?,? extends P>,S,T,A,B> Optic<P,Const<Maybe<A>,?>,S,T,Maybe<A>,B>` | Pre.`pre(Optic<P,? super Const<Maybe<A>,?>,S,T,A,B> optic)`

  - ### Uses of Maybe in com.jnape.palatable.lambda.optics.lenses

    Methods in com.jnape.palatable.lambda.optics.lenses that return types with arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <L,R> Lens.Simple<Either<L,R>,Maybe<L>>` | EitherLens.`_left()` Convenience static factory method for creating a lens over left values, wrapping them in a `Maybe`.
    `static <L,R> Lens.Simple<Either<L,R>,Maybe<R>>` | EitherLens.`_right()` Convenience static factory method for creating a lens over right values, wrapping them in a `Maybe`.
    `static <V> Lens.Simple<V,Maybe<V>>` | MaybeLens.`asMaybe()` Convenience static factory method for creating a lens that focuses on a value as a `Maybe`.
    `static <X> Lens.Simple<List<X>,Maybe<X>>` | ListLens.`elementAt(int index)` Convenience static factory method for creating a lens that focuses on an element in a list at a particular index.
    `static <A> Lens.Simple<Iterable<A>,Maybe<A>>` | IterableLens.`head()` A lens focusing on the head of a given `Iterable`.
    `static <S,T,A,B> Lens<S,T,Maybe<A>,B>` | MaybeLens.`liftA(Lens<S,T,A,B> lens)` Given a lens, lift `A` into `Maybe`.
    `static <S,T,A,B> Lens<S,T,A,Maybe<B>>` | MaybeLens.`liftB(Lens<S,T,A,B> lens, B defaultB)` Given a lens and a default `B`, lift `B` into `Maybe`.
    `static <S,T,A,B> Lens<Maybe<S>,T,A,B>` | MaybeLens.`liftS(Lens<S,T,A,B> lens, S defaultS)` Given a lens and a default `S`, lift `S` into `Maybe`.
    `static <S,T,A,B> Lens<S,Maybe<T>,A,B>` | MaybeLens.`liftT(Lens<S,T,A,B> lens)` Given a lens, lift `T` into `Maybe`.
    `static <M extends Map<K,V>,K,V> Lens<Map<K,V>,M,Maybe<V>,Maybe<V>>` | MapLens.`valueAt(Fn1<? super Map<K,V>,? extends M> copyFn, K k)` A lens that focuses on a value at a key in a map, as a `Maybe`, and produces a subtype `M` on the way back out.
    `static <M extends Map<K,V>,K,V> Lens<Map<K,V>,M,Maybe<V>,Maybe<V>>` | MapLens.`valueAt(Fn1<? super Map<K,V>,? extends M> copyFn, K k)` A lens that focuses on a value at a key in a map, as a `Maybe`, and produces a subtype `M` on the way back out.
    `static <K,V> Lens.Simple<Map<K,V>,Maybe<V>>` | MapLens.`valueAt(K k)` A lens that focuses on a value at a key in a map, as a `Maybe`.
    `static <A> Lens.Simple<HMap,Maybe<A>>` | HMapLens.`valueAt(TypeSafeKey<?,A> key)` A lens that focuses on a value at a `TypeSafeKey.Simple`<A> in an `HMap`, as a `Maybe`.

    Method parameters in com.jnape.palatable.lambda.optics.lenses with type arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <S,T,A,B> Lens<S,T,A,B>` | MaybeLens.`unLiftA(Lens<S,T,Maybe<A>,B> lens, A defaultA)` Given a lens with `A` lifted into `Maybe` and a default `A`, flatten `A` back down.
    `static <S,T,A,B> Lens<S,T,A,B>` | MaybeLens.`unLiftB(Lens<S,T,A,Maybe<B>> lens)` Given a lens with `B` lifted into `Maybe`, flatten `B` back down.
    `static <S,T,A,B> Lens<S,T,A,B>` | MaybeLens.`unLiftS(Lens<Maybe<S>,T,A,B> lens)` Given a lens with `S` lifted into `Maybe`, flatten `S` back down.
    `static <S,T,A,B> Lens<S,T,A,B>` | MaybeLens.`unLiftT(Lens<S,Maybe<T>,A,B> lens, T defaultT)` Given a lens with `T` lifted into `Maybe` and a default `T`, flatten `T` back down.

  - ### Uses of Maybe in com.jnape.palatable.lambda.optics.prisms

    Methods in com.jnape.palatable.lambda.optics.prisms that return types with arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B> Prism<Maybe<A>,Maybe<B>,A,B>` | MaybePrism.`_just()` A `Prism` that focuses on present values in a `Maybe`.
    `static <A,B> Prism<Maybe<A>,Maybe<B>,A,B>` | MaybePrism.`_just()` A `Prism` that focuses on present values in a `Maybe`.
    `static <A> Prism.Simple<Maybe<A>,Unit>` | MaybePrism.`_nothing()` A `Prism` that focuses on absent values in a `Maybe`, for symmetry.

  - ### Uses of Maybe in com.jnape.palatable.lambda.semigroup.builtin

    Methods in com.jnape.palatable.lambda.semigroup.builtin that return Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <A> Maybe<A>` | Absent.`absent(Semigroup<A> semigroup, Maybe<A> x, Maybe<A> y)`

    Methods in com.jnape.palatable.lambda.semigroup.builtin that return types with arguments of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <A> Semigroup<Maybe<A>>` | Absent.`absent(Semigroup<A> semigroup)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Absent.`absent(Semigroup<A> aSemigroup, Maybe<A> x)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Absent.`absent(Semigroup<A> aSemigroup, Maybe<A> x)`
    `Semigroup<Maybe<A>>` | Absent.`checkedApply(Semigroup<A> aSemigroup)`

    Methods in com.jnape.palatable.lambda.semigroup.builtin with parameters of type Maybe
    Modifier and Type | Method and Description
    --- | ---
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Absent.`absent(Semigroup<A> aSemigroup, Maybe<A> x)`
    `static <A> Maybe<A>` | Absent.`absent(Semigroup<A> semigroup, Maybe<A> x, Maybe<A> y)`
    `static <A> Maybe<A>` | Absent.`absent(Semigroup<A> semigroup, Maybe<A> x, Maybe<A> y)`