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
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

Subclasses of Maybe in com.jnape.palatable.lambda.adt

Modifier and Type	Class	Description
private static final class	Maybe.Just<A>
private static final class	Maybe.Nothing<A>

Classes in com.jnape.palatable.lambda.adt that implement interfaces with type arguments of type Maybe

Modifier and Type	Class	Description
class	Maybe<A>	The optional type, representing a potentially absent value.
class	Maybe<A>	The optional type, representing a potentially absent value.
class	Maybe<A>	The optional type, representing a potentially absent value.
class	Maybe<A>	The optional type, representing a potentially absent value.

Methods in com.jnape.palatable.lambda.adt with type parameters of type Maybe

Modifier and Type	Method	Description
final <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	Description
Maybe<A>	Maybe.catchError(Fn1<? super Unit, ? extends Monad<A,Maybe<?>>> recoveryFn)	Catch any thrown errors inside the Monad and resume normal operations.
final <B> Maybe<B>	Maybe.discardL(Applicative<B,Maybe<?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
final <B> Maybe<A>	Maybe.discardR(Applicative<B,Maybe<?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
final 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.
final <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.
final <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,B> Maybe<These<A,B>>	These.fromMaybes(Maybe<A> maybeA, Maybe<B> maybeB)	Convenience method for converting a pair of Maybes into a Maybe of These.
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.
final Maybe<A>	Maybe.peek(Fn1<? super A, ? extends IO<?>> effect)	Deprecated. in favor of matching into an IO and explicitly running it
final <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.
final Maybe<R>	Either.toMaybe()	In the left case, returns a Maybe.nothing(); otherwise, returns Maybe.maybe(A) around the right value.
final Maybe<A>	Try.toMaybe()	If this is a success, wrap the value in a Maybe.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.
final <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	Description
<B> Lazy<Maybe<B>>	Maybe.lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, Maybe<?>>> lazyAppFn)	Terminate early if this is a Maybe.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	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 Maybe.nothing().
static <A,B> Maybe<These<A,B>>	These.fromMaybes(Maybe<A> maybeA, Maybe<B> maybeB)	Convenience method for converting a pair of Maybes into a Maybe of These.

Method parameters in com.jnape.palatable.lambda.adt with type arguments of type Maybe

Modifier and Type	Method	Description
Maybe<A>	Maybe.catchError(Fn1<? super Unit, ? extends Monad<A,Maybe<?>>> recoveryFn)	Catch any thrown errors inside the Monad and resume normal operations.
final <B> Maybe<B>	Maybe.discardL(Applicative<B,Maybe<?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
final <B> Maybe<A>	Maybe.discardR(Applicative<B,Maybe<?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
final <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 Maybe.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.
final <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	Description
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.
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.
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.
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.
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.
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.
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.

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	Description
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>	CoProduct4.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<A>	CoProduct8.projectA()	Convenience method for projecting this coproduct onto a product and then extracting the first 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>	CoProduct4.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<B>	CoProduct8.projectB()	Convenience method for projecting this coproduct onto a product and then extracting the second 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>	CoProduct4.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<C>	CoProduct8.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>	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<D>	CoProduct8.projectD()	Convenience method for projecting this coproduct onto a product and then extracting the fourth 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<E>	CoProduct8.projectE()	Convenience method for projecting this coproduct onto a product and then extracting the fifth 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<F>	CoProduct8.projectF()	Convenience method for projecting this coproduct onto a product and then extracting the sixth 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<G>	CoProduct8.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	Description
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 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 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.
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.

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	Description
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<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.
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<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<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<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<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.

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

Subinterfaces with type arguments of type Maybe in com.jnape.palatable.lambda.adt.hmap

Modifier and Type	Interface	Description
interface	Schema<Values extends HList>	A lens that focuses on the heterogeneous list of values pointed at by one or more typesafe keys that must all exist in the same HMap to be collectively extracted.

Methods in com.jnape.palatable.lambda.adt.hmap that return Maybe

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

Classes in com.jnape.palatable.lambda.functions.builtin.fn1 that implement interfaces with type arguments of type Maybe

Modifier and Type	Class	Description
final class	CatMaybes<A>	Given an Iterable<Maybe<A>>, return an Iterable<A> of only the present values.
final class	Head<A>	Retrieve the head element of an Iterable, wrapped in an Maybe.
final class	Last<A>	Retrieve the last element of an Iterable, wrapped in a Maybe.
final class	Uncons<A>	Destructure an Iterable into a Tuple2 of its head and tail, wrapped in an Maybe.

Methods in com.jnape.palatable.lambda.functions.builtin.fn1 that return Maybe

Modifier and Type	Method	Description
Maybe<A>	Head.checkedApply(Iterable<A> as)
Maybe<A>	Last.checkedApply(Iterable<A> as)
Maybe<Tuple2<A, Iterable<A>>>	Uncons.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	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

Classes in com.jnape.palatable.lambda.functions.builtin.fn2 that implement interfaces with type arguments of type Maybe

Modifier and Type	Class	Description
final class	Find<A>	Iterate the elements in an Iterable, applying a predicate to each one, returning the first element that matches the predicate, wrapped in a Maybe.
final class	ReduceLeft<A>	Given an Iterable<A> and a Fn2<A, A, A>, iteratively accumulate over the Iterable, returning Maybe<A>.
final class	ReduceRight<A>	Given an Iterable<A> and a Fn2<A, A, A>, iteratively accumulate over the Iterable, returning Maybe<A>.
final class	Unfoldr<A,B>	Given an initial seed value and a function that takes the seed type and produces an Maybe<Tuple2<X, Seed>>, where the tuple's first slot represents the next Iterable element, and the second slot represents the next input to the unfolding function, unfold an Iterable of Xs.

Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return Maybe

Modifier and Type	Method	Description
Maybe<A>	Find.checkedApply(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as)
Maybe<A>	ReduceLeft.checkedApply(Fn2<? super A, ? super A, ? extends A> fn, Iterable<A> as)
final Maybe<A>	ReduceRight.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	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	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

Methods in com.jnape.palatable.lambda.internal that return Maybe

Modifier and Type	Method	Description
Maybe<A>	ImmutableQueue.Empty.head()
abstract Maybe<A>	ImmutableQueue.head()
Maybe<A>	ImmutableQueue.NonEmpty.head()
Maybe<A>	ImmutableStack.Empty.head()
abstract Maybe<A>	ImmutableStack.head()
Maybe<A>	ImmutableStack.Node.head()

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

Fields in com.jnape.palatable.lambda.internal.iteration declared as Maybe

Modifier and Type	Field	Description
private Maybe<Tuple2<A,B>>	UnfoldingIterator.maybeAcc

Fields in com.jnape.palatable.lambda.internal.iteration with type parameters of type Maybe

Modifier and Type	Field	Description
private final Fn1<? super B, Maybe<Tuple2<A,B>>>	UnfoldingIterator.function

Constructor parameters in com.jnape.palatable.lambda.internal.iteration with type arguments of type Maybe

Modifier	Constructor	Description
	UnfoldingIterator(Fn1<? super B, Maybe<Tuple2<A,B>>> function, B seed)

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

Fields in com.jnape.palatable.lambda.monad.transformer.builtin with type parameters of type Maybe

Modifier and Type	Field	Description
private final MonadRec<Maybe<A>,M>	MaybeT.mma
private final ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<A, IterateT<M,A>>>, M>>, MonadRec<A,M>>>	IterateT.spine

Methods in com.jnape.palatable.lambda.monad.transformer.builtin with type parameters of type Maybe

Modifier and Type	Method	Description
<MMTA extends MonadRec<Maybe<Tuple2<A, IterateT<M,A>>>, M>> MMTA	IterateT.runIterateT()	Recover the full structure of the embedded Monad.
<MMA extends MonadRec<Maybe<A>,M>> MMA	MaybeT.runMaybeT()	Recover the full structure of the embedded Monad.
<MStep extends MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M,A>>>, M>> MStep	IterateT.runStep()	Run a single step of this IterateT, where a step is the smallest amount of work that could possibly be productive in advancing through the IterateT.
<MStep extends MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M,A>>>, M>> MStep	IterateT.runStep()	Run a single step of this IterateT, where a step is the smallest amount of work that could possibly be productive in advancing through the IterateT.

Method parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type Maybe

Modifier and Type	Method	Description
static <M extends MonadRec<?,M>, A> IterateT<M,A>	IterateT.iterateT(MonadRec<Maybe<Tuple2<A, IterateT<M,A>>>, M> unwrapped)	Static factory method for wrapping an uncons of an IterateT in an IterateT.
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.
static <M extends MonadRec<?,M>, A> IterateT<M,A>	IterateT.suspended(Fn0<MonadRec<Maybe<Tuple2<A, IterateT<M,A>>>, M>> thunk, Pure<M> pureM)	Create an IterateT from a suspended computation that yields the spine of the IterateT inside the effect.
static <M extends MonadRec<?,M>, A, B> IterateT<M,A>	IterateT.unfold(Fn1<? super B, ? extends MonadRec<Maybe<Tuple2<A,B>>, M>> fn, MonadRec<B,M> mb)	Lazily unfold an IterateT from an unfolding function fn and a starting seed value mb by successively applying fn to the latest seed value, producing maybe a value to yield out and the next seed value for the subsequent computation.

Constructor parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type Maybe

Modifier	Constructor	Description
private	IterateT(Pure<M> pureM, ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<A, IterateT<M,A>>>, M>>, MonadRec<A,M>>> spine)
private	MaybeT(MonadRec<Maybe<A>,M> mma)

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

Classes in com.jnape.palatable.lambda.monoid.builtin that implement interfaces with type arguments of type Maybe

Modifier and Type	Class	Description
final class	First<A>	A Monoid instance formed by Maybe<A>.
final class	Last<A>	A Monoid instance formed by Maybe<A>.
final class	Present<A>	A Monoid instance formed by Maybe<A> and a semigroup over A.

Methods in com.jnape.palatable.lambda.monoid.builtin that return Maybe

Modifier and Type	Method	Description
Maybe<A>	First.checkedApply(Maybe<A> x, Maybe<A> y)
Maybe<A>	Last.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>	First.identity()
Maybe<A>	Last.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	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	Description
Maybe<A>	First.checkedApply(Maybe<A> x, Maybe<A> y)
Maybe<A>	Last.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> Fn1<Maybe<A>,Maybe<A>>	Last.last(Maybe<A> x)
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)

Method parameters in com.jnape.palatable.lambda.monoid.builtin with type arguments of type Maybe

Modifier and Type	Method	Description
<B> Maybe<A>	First.foldMap(Fn1<? super B, ? extends Maybe<A>> fn, Iterable<B> bs)
private static <A> Fn2<HMap,HMap,HMap>	MergeHMaps.merge(TypeSafeKey<?,A> key, Semigroup<Maybe<A>> semigroup)

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	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

Classes in com.jnape.palatable.lambda.optics.functions that implement interfaces with type arguments of type Maybe

Modifier and Type	Class	Description
final class	Pre<P extends Profunctor<?, ?, ? extends P>, S, T, A, B>	Turn an Optic with a unary mapping that can be used for viewing some number of values into an Optic that views the first value, if it exists.
final class	Pre<P extends Profunctor<?, ?, ? extends P>, S, T, A, B>	Turn an Optic with a unary mapping that can be used for viewing some number of values into an Optic that views the first value, if it exists.
final class	Pre<P extends Profunctor<?, ?, ? extends P>, S, T, A, B>	Turn an Optic with a unary mapping that can be used for viewing some number of values into an Optic that views the first value, if it exists.

Methods in com.jnape.palatable.lambda.optics.functions that return types with arguments of type Maybe

Modifier and Type	Method	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	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	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 <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.
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.

Method parameters in com.jnape.palatable.lambda.optics.lenses with type arguments of type Maybe

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

Classes in com.jnape.palatable.lambda.semigroup.builtin that implement interfaces with type arguments of type Maybe

Modifier and Type	Class	Description
final class	Absent<A>	A Semigroup instance formed by Maybe<A> and a semigroup over A.

Methods in com.jnape.palatable.lambda.semigroup.builtin that return Maybe

Modifier and Type	Method	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	Description
static <A> Semigroup<Maybe<A>>	Absent.absent(Semigroup<A> aSemigroup)
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)
private static <A> Semigroup<Maybe<A>>	Absent.shortCircuitSemigroup(Semigroup<A> aSemigroup)

Methods in com.jnape.palatable.lambda.semigroup.builtin with parameters of type Maybe

Modifier and Type	Method	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)