All Classes

All Classes Interface Summary Class Summary Exception Summary
Class	Description
$<A,B>	Function application, represented as a higher-order `Fn2` that receives an `Fn1` and its argument, and applies it.
Absent<A>	A `Semigroup` instance formed by `Maybe<A>` and a semigroup over `A`.
AddAll<A,C extends java.util.Collection<A>>	The `Monoid` instance formed under mutative concatenation for an arbitrary `Collection`.
All<A>	Eagerly apply a predicate to each element in an `Iterable`, returning `true` if every element satisfies the predicate, and `false` otherwise.
Alter<A>	Given an `Effect<A>` and some `A`, produce an `IO` that, when run, performs the effect on `A` and returns it.
And	A `Monoid` instance formed by `Boolean`.
Any<A>	Eagerly apply a predicate to each element in an `Iterable`, returning `true` if any element satisfies the predicate, and `false` otherwise.
Applicative<A,App extends Applicative<?,App>>	An interface representing applicative functors - functors that can have their results combined with other functors of the same instance in a context-free manner.
AutoBracket<A extends java.lang.AutoCloseable,B>	Given an `IO` yielding some `AutoCloseable` type `A` and a kleisli arrow from that type to a new `IO` of type `B`, attempt to provision the `A`, applying the body operation if provisioning was successful and ensuring that `AutoCloseable.close()` is called regardless of whether the body succeeds or fails.
Between<A extends java.lang.Comparable<A>>	Given two bounds and a value, return whether or not the value is greater than or equal to the lower bound and less than or equal to the upper bound.
Bifunctor<A,B,BF extends Bifunctor<?,?,BF>>	A dually-parametric functor that maps covariantly over both parameters.
BiMonoidFactory<A,B,C>
BiPredicate<A,B>	A specialized `Fn2` that returns a Boolean when fully applied, or a `Predicate` when partially applied.
BiSemigroupFactory<A,B,C>
Both<A,B,C>	Given two functions `f` and `g`, produce a `Fn1<A, Tuple2<B, C>>` (the dual application of both functions).
BoundedBifunctor<A extends ContraA,B extends ContraB,ContraA,ContraB,BF extends BoundedBifunctor<?,?,?,?,BF>>	A `Bifunctor` that has both parameter types upper bounded; that is, neither parameters can be mapped to a value that is not covariant to their respective upper bounds
Bracket<A,B>	Given an `IO` that yields some type `A`, a cleanup operation to run if a value of that type could be provisioned, and a kleisli arrow from that type to a new `IO` of type `B`, produce an `IO<B>` that, when run, will provision the `A`, `flatMap` it to `B`, and clean up the original value if it was produced in the first place.
Cartesian<A,B,P extends Cartesian<?,?,P>>	`Profunctor` strength in the cartesian product sense: `p a b -> p (c ^ a) (c ^ b)` for any type `c`.
CartesianProduct<A,B>	Lazily compute the cartesian product of an `Iterable<A>` and `Iterable<B>`, returning an `Iterable<Tuple2<A, B>>`, the products as tuples of multiplicand `A`s and multiplier `B`s.
CatMaybes<A>	Given an `Iterable<Maybe<A>>`, return an `Iterable<A>` of only the present values.
Choice2<A,B>	Canonical ADT representation of `CoProduct2`.
Choice2._A<A,B>
Choice2._B<A,B>
Choice3<A,B,C>	Canonical ADT representation of `CoProduct3`.
Choice3._A<A,B,C>
Choice3._B<A,B,C>
Choice3._C<A,B,C>
Choice4<A,B,C,D>	Canonical ADT representation of `CoProduct4`.
Choice4._A<A,B,C,D>
Choice4._B<A,B,C,D>
Choice4._C<A,B,C,D>
Choice4._D<A,B,C,D>
Choice5<A,B,C,D,E>	Canonical ADT representation of `CoProduct5`.
Choice5._A<A,B,C,D,E>
Choice5._B<A,B,C,D,E>
Choice5._C<A,B,C,D,E>
Choice5._D<A,B,C,D,E>
Choice5._E<A,B,C,D,E>
Choice6<A,B,C,D,E,F>	Canonical ADT representation of `CoProduct6`.
Choice6._A<A,B,C,D,E,F>
Choice6._B<A,B,C,D,E,F>
Choice6._C<A,B,C,D,E,F>
Choice6._D<A,B,C,D,E,F>
Choice6._E<A,B,C,D,E,F>
Choice6._F<A,B,C,D,E,F>
Choice7<A,B,C,D,E,F,G>	Canonical ADT representation of `CoProduct7`.
Choice7._A<A,B,C,D,E,F,G>
Choice7._B<A,B,C,D,E,F,G>
Choice7._C<A,B,C,D,E,F,G>
Choice7._D<A,B,C,D,E,F,G>
Choice7._E<A,B,C,D,E,F,G>
Choice7._F<A,B,C,D,E,F,G>
Choice7._G<A,B,C,D,E,F,G>
Choice8<A,B,C,D,E,F,G,H>	Canonical ADT representation of `CoProduct8`.
Choice8._A<A,B,C,D,E,F,G,H>
Choice8._B<A,B,C,D,E,F,G,H>
Choice8._C<A,B,C,D,E,F,G,H>
Choice8._D<A,B,C,D,E,F,G,H>
Choice8._E<A,B,C,D,E,F,G,H>
Choice8._F<A,B,C,D,E,F,G,H>
Choice8._G<A,B,C,D,E,F,G,H>
Choice8._H<A,B,C,D,E,F,G,H>
Clamp<A extends java.lang.Comparable<A>>	Given two bounds and a value, "clamp" the value between the bounds via the following algorithm: - if the value is strictly less than the lower bound, return the lower bound - if the value is strictly greater than the upper bound, return the upper bound - otherwise, return the value
CmpEq<A extends java.lang.Comparable<A>>	Given two `Comparable` values of type `A`, return `true` if the first value is strictly equal to the second value (according to `Comparable.compareTo(Object)`; otherwise, return false.
CmpEqBy<A,B extends java.lang.Comparable<B>>	Given a mapping function from some type `A` to some `Comparable` type `B` and two values of type `A`, return `true` if the first value is strictly equal to the second value (according to `Comparable.compareTo(Object)` in terms of their mapped `B` results; otherwise, return false.
CmpEqWith<A>	Given a `Comparator` from some type `A` and two values of type `A`, return `true` if the first value is strictly equal to the second value (according to `Comparator.compare(Object, Object)` otherwise, return false.
Coalesce<L,R>	Fold an `Iterable<Either<L, R>>` into an `Either<Iterable<L>, Iterable<R>>`, preserving all results of the side that's returned.
Cocartesian<A,B,P extends Cocartesian<?,?,P>>	`Profunctor` strength in the cocartesian coproduct sense: `p a b -> p (c v a) (c v b)` for any type `c`.
Collapse<_1,_2>	A `Monoid` instance formed by a `Tuple2<_1, _2>` and monoids over `_1` and `_2`.
Collapse<_1,_2>	A `Semigroup` instance formed by a `Tuple2<_1, _2>` and semigroups over `_1` and `_2`.
CollectionLens	Lenses that operate on `Collection`s.
CombinatorialIterator<A,B>
Compare<A>	Given a `Comparator` from some type `A` and two values of type `A`, return a `ComparisonRelation` of the first value with reference to the second value (according to `Comparator.compare(Object, Object)`.
ComparisonRelation	Specialized `CoProduct3` representing the possible results of a ordered comparison.
ComparisonRelation.Equal
ComparisonRelation.GreaterThan
ComparisonRelation.LessThan
Compose<F extends Applicative<?,F>,G extends Applicative<?,G>,A>	A functor representing the type-level composition of two `Applicative` functors; useful for preserving nested type-level transformations during traversal of a `Traversable`.
Compose<A>	A `Monoid` instance formed by `CompletableFuture<A>` and a monoid over `A`.
Compose<A>	A `Semigroup` instance formed by `CompletableFuture<A>` and a semigroup over `A`.
Concat<A>	The `Monoid` instance formed under concatenation for an arbitrary `Iterable`.
ConcatenatingIterable<A>
Cons<A>	Prepend an element to an `Iterable`.
ConsingIterator<A>
Const<A,B>	A (surprisingly useful) functor over some phantom type `B`, retaining a value of type `A` that can be retrieved later.
Constantly<A,B>	A function that takes two arguments and always returns the first argument.
Contravariant<A,C extends Contravariant<?,C>>	The contravariant functor (or "co-functor"); that is, a functor that maps contravariantly (`A <- B`) over its parameter.
CoProduct2<A,B,CP2 extends CoProduct2<A,B,?>>	A generalization of the coproduct of two types.
CoProduct3<A,B,C,CP3 extends CoProduct3<A,B,C,?>>	A generalization of the coproduct of three types.
CoProduct4<A,B,C,D,CP4 extends CoProduct4<A,B,C,D,?>>	A generalization of the coproduct of four types.
CoProduct5<A,B,C,D,E,CP5 extends CoProduct5<A,B,C,D,E,?>>	A generalization of the coproduct of five types.
CoProduct6<A,B,C,D,E,F,CP6 extends CoProduct6<A,B,C,D,E,F,?>>	A generalization of the coproduct of six types.
CoProduct7<A,B,C,D,E,F,G,CP7 extends CoProduct7<A,B,C,D,E,F,G,?>>	A generalization of the coproduct of seven types.
CoProduct8<A,B,C,D,E,F,G,H,CP8 extends CoProduct8<A,B,C,D,E,F,G,H,?>>	A generalization of the coproduct of eight types.
Cycle<A>	Given an `Iterable`, return an infinite `Iterable` that repeatedly cycles its elements, in order.
CyclicIterable<A>
CyclicIterator<A>
Difference<A>	Given two `Iterables` `xs` and `ys`, return the `distinct` elements of `xs` that are not in `ys`.
Distinct<A>	Return an `Iterable` of the distinct values from the given input `Iterable`.
DistinctIterable<A>
Downcast<A extends B,B>	Covariantly cast a value of type `B` to a value of subtype `A`.
Drop<A>	Lazily skip the first `n` elements from an `Iterable` by returning an `Iterable` that begins iteration after the `nth` element.
DroppingIterable<A>
DroppingIterator<A>
DropWhile<A>	Lazily limit the `Iterable` by skipping the first contiguous group of elements that satisfy the predicate, beginning iteration at the first element for which the predicate evaluates to `false`.
Effect<A>	A function returning "no result", and therefore only useful as a side-effect.
Either<L,R>	The binary tagged union, implemented as a specialized `CoProduct2`.
Either.Left<L,R>
Either.Right<L,R>
EitherLens	Lenses for `Either`.
EitherPrism	`Prisms` for `Either`.
EitherT<M extends MonadRec<?,M>,L,R>	A `monad transformer` for `Either`.
Empty<A>	A predicate that returns true if `as` is empty; false otherwise.
Endo<A>	A `Monoid` formed by `Fn1` under composition.
EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>	The monoid formed under monadic endomorphism.
Eq<A>	Type-safe equality in function form; uses `Object.equals(java.lang.Object)`, not `==`.
Exchange<A,B,S,T>	A profunctor used to extract the isomorphic functions an `Iso` is composed of.
Filter<A>	Lazily apply a predicate to each element in an `Iterable`, returning an `Iterable` of just the elements for which the predicate evaluated to `true`.
FilteringIterable<A>
FilteringIterator<A>
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`.
First<A>	A `Monoid` instance formed by `Maybe<A>`.
Flatten<A>	Given a nested `Iterable` of `Iterable`s, return a lazily flattening `Iterable` of the nested elements.
FlatteningIterator<A>
Fn0<A>	A function taking "no arguments", implemented as an `Fn1<Unit, A>`.
Fn1<A,B>	A function taking a single argument.
Fn2<A,B,C>	A function taking two arguments.
Fn3<A,B,C,D>	A function taking three arguments.
Fn4<A,B,C,D,E>	A function taking four arguments.
Fn5<A,B,C,D,E,F>	A function taking five arguments.
Fn6<A,B,C,D,E,F,G>	A function taking six arguments.
Fn7<A,B,C,D,E,F,G,H>	A function taking seven arguments.
Fn8<A,B,C,D,E,F,G,H,I>	A function taking eight arguments.
FoldLeft<A,B>	Given an `Iterable` of `A`s, a starting value `B`, and a `Fn2<B, A, B>`, iteratively accumulate over the `Iterable`, ultimately returning a final `B` value.
FoldRight<A,B>	Given an `Iterable` of `A`s, a starting `lazy` value `B`, and a `Fn2<A, Lazy<B>, Lazy<B>>`, iteratively accumulate over the `Iterable`, ultimately returning a final `Lazy<B>` value.
Force<A>	Deprecated. in favor of `traversing` into an `IO` and running it
Functor<A,F extends Functor<?,F>>	An interface for the generic covariant functorial operation `map` over some parameter `A`.
GroupBy<K,V>	Given an `Iterable<V>` `vs` and a key function `V -> K` `f`, fold `vs` into a `Map<K, List<V>>` by applying `f` to each element of `vs`, retaining values that map to the same key in a list, in the order they were iterated in.
GroupingIterator<A>
GT<A extends java.lang.Comparable<A>>	Given two `Comparable` values of type `A`, return `true` if the second value is strictly greater than the first value; otherwise, return false.
GTBy<A,B extends java.lang.Comparable<B>>	Given a mapping function from some type `A` to some `Comparable` type `B` and two values of type `A`, return `true` if the second value is strictly greater than the first value in terms of their mapped `B` results; otherwise, return false.
GTE<A extends java.lang.Comparable<A>>	Given two `Comparable` values of type `A`, return `true` if the second value is greater than or equal to the first value according to `Comparable.compareTo(Object)`; otherwise, return false.
GTEBy<A,B extends java.lang.Comparable<B>>	Given a mapping function from some type `A` to some `Comparable` type `B` and two values of type `A`, return `true` if the second value is greater than or equal to the first value in terms of their mapped `B` results according to `Comparable.compareTo(Object)`; otherwise, return false.
GTEWith<A>	Given a `Comparator` from some type `A` and two values of type `A`, return `true` if the second value is greater than or equal to the first value in terms of their mapped `B` results according to `Comparator.compare(Object, Object)`; otherwise, return false.
GTWith<A>	Given a `Comparator` from some type `A` and two values of type `A`, return `true` if the second value is strictly greater than the first value in terms of their mapped `B` results; otherwise, return false.
Head<A>	Retrieve the head element of an `Iterable`, wrapped in an `Maybe`.
HList	An immutable heterogeneous list supporting arbitrary depth type-safety via a linearly recursive type signature.
HList.HCons<Head,Tail extends HList>	The consing of a head element to a tail `HList`.
HList.HNil	The empty `HList`.
HListLens	Lenses that operate on `HList`s.
HMap	An immutable heterogeneous mapping from a parametrized type-safe key to any value, supporting a minimal mapping interface.
HMapLens	Lenses that operate on `HMap`s.
Id<A>	The identity function.
Identity<A>	A functor over some value of type `A` that can be mapped over and retrieved later.
IdentityT<M extends MonadRec<?,M>,A>	A `monad transformer` for `Identity`.
IfThenElse<A,B>
ImmutableIterator<Element>
ImmutableQueue<A>	Internal API.
ImmutableQueue.Empty<A>
ImmutableQueue.NonEmpty<A>
ImmutableStack<A>	Internal API.
ImmutableStack.Empty<A>
ImmutableStack.Node<A>
Index<Target,TargetList extends HList.HCons<?,?>>	HList indexes representing a value at arbitrary depth in some compatible HList.
Index.N<Target,Head,List extends HList.HCons<?,?>,PreviousIndex extends Index<Target,List>>
Index.Z<Target>
InfiniteIterator<A>
InGroupsOf<A>	Lazily group the `Iterable` by returning an `Iterable` of smaller `Iterable`s of size `k`.
Init<A>	Given an `Iterable<A>`, produce an `Iterable<A>` of all elements but the last one.
InitIterator<A>
Inits<A>	Given an `Iterable<A>`, produce an `Iterable<Iterable<A>>`, representing all of the subsequences of initial elements, ordered by size, starting with the empty `Iterable`.
Intersection<A>	Given two `Iterables` `xs` and `ys`, return the `distinct` elements of `xs` that are also in `ys` in order of their unique occurrence in `xs`.
Intersperse<A>	Lazily inject the provided separator value between each value in the supplied `Iterable`.
Into<A,B,C>	Given an `Fn2<A, B, C>` and a `Map.Entry<A, B>`, destructure the entry and apply the key and value as arguments to the function, returning the result.
Into1<A,B>	Given an `Fn1<A, B>` and a `SingletonHList<A>`, pop the head and apply it to the function, returning the result.
Into3<A,B,C,D>	Given an `Fn3<A, B, C, D>` and a `Product3<A, B, C>`, destructure the product and apply the slots as arguments to the function, returning the result.
Into4<A,B,C,D,E>	Given an `Fn4<A, B, C, D, E>` and a `Product4<A, B, C, D>`, destructure the product and apply the slots as arguments to the function, returning the result.
Into5<A,B,C,D,E,F>	Given an `Fn5<A, B, C, D, E, F>` and a `Product5<A, B, C, D, E>`, destructure the product and apply the slots as arguments to the function, returning the result.
Into6<A,B,C,D,E,F,G>	Given an `Fn6<A, B, C, D, E, F, G>` and a `Product6<A, B, C, D, E, F>`, destructure the product and apply the slots as arguments to the function, returning the result.
Into7<A,B,C,D,E,F,G,H>	Given an `Fn7<A, B, C, D, E, F, G, H>` and a `Product7<A, B, C, D, E, F, G>`, destructure the product and apply the slots as arguments to the function, returning the result.
Into8<A,B,C,D,E,F,G,H,I>	Given an `Fn8<A, B, C, D, E, F, G, H, I>` and a `Product8<A, B, C, D, E, F, G, H>`, destructure the product and apply the slots as arguments to the function, returning the result.
IO<A>	A `Monad` representing some side-effecting computation to be performed.
IO.Compose<A>
Iso<S,T,A,B>	An `Iso` (short for "isomorphism") is an invertible `Lens`: an `Optic` encoding of a bi-directional focusing of two types, and like `Lenses`, can be `Viewed`, `Set`, and `updated`.
Iso.Simple<S,A>	A convenience type with a simplified type signature for common isos with both unified "larger" values and unified "smaller" values.
IterableLens	Lenses that operate on `Iterable`s.
Iterate<A>	Lazily generate an infinite `Iterable` from the successive applications of the function first to the initial seed value, then to the result, and so on; i.e., the result of `iterate(x -> x + 1, 0)` would produce an infinite `Iterable` over the elements `0, 1, 2, 3, ...`
IterateT<M extends MonadRec<?,M>,A>	A `monad transformer` over a co-inductive, singly-linked spine of values embedded in effects.
IterationInterruptedException	An exception thrown when a thread is interrupted while an `Iterator` was blocked.
Join	A `Monoid` instance formed by `String` that concats two strings together.
Kleisli<A,B,M extends Monad<?,M>,MB extends Monad<B,M>>	The Kleisli arrow of a `Monad`, manifest as simply an `Fn1<A, MB>`.
LambdaIterable<A>	Extension point for `Iterable` to adapt lambda core types like `Monad` and `Traversable`.
LambdaMap<A,B>	Extension point for `Map` to adapt lambda core types like `Functor` and `Traversable`.
Last<A>	Retrieve the last element of an `Iterable`, wrapped in a `Maybe`.
Last<A>	A `Monoid` instance formed by `Maybe<A>`.
Lazy<A>	A `Monad` representing a lazily-computed value.
Lazy.Compose<A>
Lazy.Later<A>
LazyRec<A,B>	Given a `Fn2` that receives a recursive function and an input and yields a `lazy` result, and an input, produce a `lazy` result that, when forced, will recursively invoke the function until it terminates in a stack-safe way.
LazyT<M extends MonadRec<?,M>,A>	A `monad transformer` for `Lazy`.
LeftAll<L,R>	A `Monoid` instance formed by `Either<L,R>` and a monoid over `L`.
LeftAll<L,R>	A `Semigroup` instance formed by `Either<L,R>` and a semigroup over `L`.
LeftAny<L,R>	A `Monoid` instance formed by `Either<L,R>` and a monoid over `L`.
LeftAny<L,R>	A `Semigroup` instance formed by `Either<L,R>` and a semigroup over `L`.
Lens<S,T,A,B>	An approximation of van Laarhoven lenses.
Lens.Simple<S,A>	A convenience type with a simplified type signature for common lenses with both unified "larger" values and unified "smaller" values.
Lift<B extends MonadBase<?,?,B>>	Generalized, portable lifting operation for lifting a `MonadRec` into a `MonadBase`.
LiftA2<A,B,C,App extends Applicative<?,App>,AppC extends Applicative<C,App>>	Lift into and apply an `Fn2` to two `Applicative` values, returning the result inside the same `Applicative` context.
LiftA3<A,B,C,D,App extends Applicative<?,App>,AppD extends Applicative<D,App>>	Lift into and apply an `Fn3` to three `Applicative` values, returning the result inside the same `Applicative` context.
LiftA4<A,B,C,D,E,App extends Applicative<?,App>,AppE extends Applicative<E,App>>	Lift into and apply an `Fn4` to four `Applicative` values, returning the result inside the same `Applicative` context.
LiftA5<A,B,C,D,E,F,App extends Applicative<?,App>,AppF extends Applicative<F,App>>	Lift into and apply an `Fn5` to five `Applicative` values, returning the result inside the same `Applicative` context.
LiftA6<A,B,C,D,E,F,G,App extends Applicative<?,App>,AppG extends Applicative<G,App>>	Lift into and apply an `Fn6` to six `Applicative` values, returning the result inside the same `Applicative` context.
LiftA7<A,B,C,D,E,F,G,H,App extends Applicative<?,App>,AppH extends Applicative<H,App>>	Lift into and apply an `Fn7` to seven `Applicative` values, returning the result inside the same `Applicative` context.
ListLens	Lenses that operate on `List`s.
LT<A extends java.lang.Comparable<A>>	Given two `Comparable` values of type `A`, return `true` if the second value is strictly less than the first value; otherwise, return false.
LTBy<A,B extends java.lang.Comparable<B>>	Given a mapping function from some type `A` to some `Comparable` type `B` and two values of type `A`, return `true` if the second value is strictly less than the first value in terms of their mapped `B` results; otherwise, return false.
LTE<A extends java.lang.Comparable<A>>	Given two `Comparable` values of type `A`, return `true` if the second value is less than or equal to the first value according to `Comparable.compareTo(Object)` otherwise, return false.
LTEBy<A,B extends java.lang.Comparable<B>>	Given a mapping function from some type `A` to some `Comparable` type `B` and two values of type `A`, return `true` if the second value is less than or equal to the first value in terms of their mapped `B` results according to `Comparable.compareTo(Object)`; otherwise, return false.
LTEWith<A>	Given a `Comparator` from some type `A` and two values of type `A`, return `true` if the second value is less than or equal to the first value in terms of their mapped `B` results according to `Comparator.compare(Object, Object)`; otherwise, return false.
LTWith<A>	Given a comparator for some type `A` and two values of type `A`, return `true` if the second value is strictly less than than the first value in terms of their mapped `B` results; otherwise, return false.
Magnetize<A>	`Magnetize` an `Iterable` using value equality as the magnetizing function.
MagnetizeBy<A>	Given a binary predicate and an `Iterable<A>`, return an `Iterable<Iterable<A>>` of the contiguous groups of elements that match the predicate pairwise.
Map<A,B>	Lazily apply a function to each element in an `Iterable`, producing an `Iterable` of the mapped results.
MapLens	Lenses that operate on `Map`s.
MappingIterable<A,B>
MappingIterator<A,B>
MapPrism	`Prisms` for `Maps`.
Market<A,B,S,T>	A profunctor used to extract the isomorphic functions a `Prism` is composed of.
Matching<S,T,A,B>
Max<A extends java.lang.Comparable<A>>	A `Semigroup` over `A` that chooses between two values `x` and `y` via the following rules: If `x` is strictly less than `y`, return `y` Otherwise, return `x`
MaxBy<A,B extends java.lang.Comparable<B>>	Given a mapping function from some type `A` to some `Comparable` type `B`, produce a `Semigroup` over `A` that chooses between two values `x` and `y` via the following rules: If `x` is strictly less than `y` in terms of `B`, return `y` Otherwise, return `x`
MaxWith<A>	Given a comparator for some type `A`, produce a `Semigroup` over `A` that chooses between two values `x` and `y` via the following rules: If `x` is strictly less than `y` in terms of `B`, return `y` Otherwise, return `x`
Maybe<A>	The optional type, representing a potentially absent value.
Maybe.Just<A>
Maybe.Nothing<A>
MaybeLens	Lenses that operate on `Maybe`.
MaybePrism	`Prisms` for `Maybe`.
MaybeT<M extends MonadRec<?,M>,A>	A `monad transformer` for `Maybe`.
Merge<L,R>	A `Monoid` instance formed by `Either.merge(com.jnape.palatable.lambda.functions.Fn2<? super L, ? super L, ? extends L>, com.jnape.palatable.lambda.functions.Fn2<? super R, ? super R, ? extends R>, com.jnape.palatable.lambda.adt.Either<L, R>...)`, a semigroup over `L`, and a monoid over `R`.
Merge<L,R>	A `Semigroup` instance formed by `Either.merge(com.jnape.palatable.lambda.functions.Fn2<? super L, ? super L, ? extends L>, com.jnape.palatable.lambda.functions.Fn2<? super R, ? super R, ? extends R>, com.jnape.palatable.lambda.adt.Either<L, R>...)` and semigroups over `L` and `R`.
MergeHMaps	A `Monoid` instance formed by merging `HMaps` using the chosen `TypeSafeKey -> Semigroup` `mappings`, defaulting to `Last` in case no `Semigroup` has been chosen for a given `TypeSafeKey`.
MergeHMaps.Φ<R>
MergeMaps<K,V>	A `Monoid` instance formed by `Map.merge(Object, Object, BiFunction)` and a semigroup over `V`.
Min<A extends java.lang.Comparable<A>>	A `Semigroup` over `A` that chooses between two values `x` and `y` via the following rules: If `x` is strictly greater than `y`, return `y` Otherwise, return `x`
MinBy<A,B extends java.lang.Comparable<B>>	Given a mapping function from some type `A` to some `Comparable` type `B`, produce a `Semigroup` over `A` that chooses between two values `x` and `y` via the following rules: If `x` is strictly greater than `y` in terms of `B`, return `y` Otherwise, return `x`
MinWith<A>	Given a comparator for some type `A`, produce a `Semigroup` over `A` that chooses between two values `x` and `y` via the following rules: If `x` is strictly greater than `y` in terms of `B`, return `y` Otherwise, return `x`
Monad<A,M extends Monad<?,M>>	Monads are `Applicative` functors that support a flattening operation to unwrap `M<M<A>> -> M<A>`.
MonadBase<M extends MonadRec<?,M>,A,MB extends MonadBase<?,?,MB>>	A type into which a `MonadRec` is embedded whilst internally preserving the `MonadRec` structure.
MonadError<E,A,M extends MonadError<E,?,M>>	An interface for `monads` that can be interrupted with some type of error.
MonadReader<R,A,MR extends MonadReader<R,?,MR>>	A monad that is capable of reading an environment `R` and producing a lifted value `A`.
MonadRec<A,M extends MonadRec<?,M>>	A class of `monads` that offer a stack-safe interface for performing arbitrarily many `flatmap-like` operations via `MonadRec.trampolineM(Fn1)`.
MonadT<M extends MonadRec<?,M>,A,MT extends MonadT<M,?,MT,T>,T extends MonadT<?,?,?,T>>	The generic type representing a `Monad` transformer, exposing the argument `Monad` as a type parameter.
MonadWriter<W,A,MW extends MonadWriter<W,?,MW>>	A `Monad` that is capable of writing and accumulating state alongside a value, but is not necessarily capable of simultaneously accessing the state and the value.
Monoid<A>	A `Monoid` is the pairing of a `Semigroup` with an identity element.
MonoidFactory<A,B>
Not<A>	Negate a predicate function.
Occurrences<A>	Given an `Iterable<A>`, return a `Map<A, Long>` representing each unique element in the `Iterable` paired with its number of occurrences.
Optic<P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,T,A,B>	A generic supertype representation for profunctor optics.
Optic.Simple<P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,A>	An convenience type with a simplified signature for `optics` with unified `S/T` and `A/B` types.
Or	A `Monoid` instance formed by `Boolean`.
Over<S,T,A,B>	Given an `Optic`, a function from `A` to `B`, and a "larger" value `S`, produce a `T` by retrieving the `A` from the `S`, applying the function, and updating the `S` with the `B` resulting from the function.
Partition<A,B,C>	Given an `Iterable<A>` `as` and a disjoint mapping function `a -> CoProduct2<A, B>`, return a `Tuple2` over the lazily unwrapped left `A` and right `B` values in the first and second slots, respectively.
Peek<A,FA extends Functor<A,?>>	Deprecated. in favor of producing an `IO` from the given `Functor` and explicitly running it
Peek2<A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>>	Deprecated. in favor of producing an `IO` from the given `BoundedBifunctor` and explicitly running it
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.
Predicate<A>	A specialized `Fn1` that returns a `Boolean`.
PredicatedDroppingIterable<A>
PredicatedDroppingIterator<A>
PredicatedTakingIterable<A>
PredicatedTakingIterator<A>
PrependAll<A>	Lazily prepend each value with of the `Iterable` with the supplied separator value.
PrependingIterator<A>
Present<A>	A `Monoid` instance formed by `Maybe<A>` and a semigroup over `A`.
Prism<S,T,A,B>	Prisms are `Isos` that can fail in one direction.
Prism.Simple<S,A>	A convenience type with a simplified type signature for common `prism` with unified `S/T` and `A/B` types.
Product2<_1,_2>	The minimal shape of the combination of two potentially distinctly typed values, supporting destructuring via explicitly named indexing methods, as well as via a combining function.
Product3<_1,_2,_3>	A product with three values.
Product4<_1,_2,_3,_4>	A product with four values.
Product5<_1,_2,_3,_4,_5>	A product with five values.
Product6<_1,_2,_3,_4,_5,_6>	A product with six values.
Product7<_1,_2,_3,_4,_5,_6,_7>	A product with seven values.
Product8<_1,_2,_3,_4,_5,_6,_7,_8>	A product with eight values.
Profunctor<A,B,PF extends Profunctor<?,?,PF>>	A dually-parametric functor that maps contravariantly over the left parameter and covariantly over the right.
ProtoOptic<P extends Profunctor<?,?,? extends P>,S,T,A,B>	A generic supertype representation for a profunctor `Optic` that requires a `Pure` implementation to derive its `Functor` constraint and graduate to a full-fledge `Optic`, equipped with a default `Optic` instance for the profunctor constraint and `Identity`.
Pure<F extends Functor<?,? extends F>>	Generalized, portable `Applicative.pure(Object)`, with a loosened `Functor` constraint.
PutAll	A `Monoid` instance formed by `HMap` that simply combines all the mappings.
RateLimit<A>	Given an `Fn0` of `Instants` (presumably backed by a clock), a `limit`, a `Duration`, and an `Iterable` `as`, return an `Iterable` that iterates `as` according to the threshold specified by the limit per duration, using the `Fn0` to advance time.
RateLimitingIterable<A>
RateLimitingIterator<A>
Re<S,T,A,B>	Turn an `Optic` with a unary mapping that can be used for setting (e.g.
ReaderT<R,M extends MonadRec<?,M>,A>	A `monad transformer` for any `function` from some type `R` to some `monadic` embedding `MonadRec<A, M>`.
RecursiveResult<A,B>	Specialized `CoProduct2` representing the possible results of a primitive recursive function.
RecursiveResult.Recurse<A,B>
RecursiveResult.Terminate<A,B>
ReduceLeft<A>	Given an `Iterable<A>` and a `Fn2<A, A, A>`, iteratively accumulate over the `Iterable`, returning `Maybe<A>`.
ReduceRight<A>	Given an `Iterable<A>` and a `Fn2<A, A, A>`, iteratively accumulate over the `Iterable`, returning `Maybe<A>`.
Repeat<A>	Given a value, return an infinite `Iterable` that repeatedly iterates that value.
RepetitiousIterator<A>
Replicate<A>	Produce an `Iterable` of a value `n` times.
Reverse<A>	Given an `Iterable`, return a reversed representation of that `Iterable`.
ReversingIterable<A>
ReversingIterator<A>
RewindableIterator<A>
RewindableIterator.Cache<A>
RightAll<L,R>	A `Monoid` instance formed by `Either<L,R>` and a monoid over `R`.
RightAll<L,R>	A `Semigroup` instance formed by `Either<L,R>` and a semigroup over `R`.
RightAny<L,R>	A `Monoid` instance formed by `Either<L,R>` and a monoid over `R`.
RightAny<L,R>	A `Semigroup` instance formed by `Either<L,R>` and a semigroup over `R`.
RunAll<A>	Run `IO` operations, aggregating their results in terms of the provided `Monoid`.
RunAll<A>	Run `IO` operations, aggregating their results in terms of the provided `Semigroup`.
Runtime
SafeT<M extends MonadRec<?,M>,A>	A stack-safe `monad transformer` that can safely interpret deeply nested left- or right-associated binds for any `MonadRec`.
SafeT.Body<M extends MonadRec<?,M>,A>
SafeT.Body.Done<M extends MonadRec<?,M>,A>
SafeT.Body.More<M extends MonadRec<?,M>,A>
SafeT.Body.Suspended<M extends MonadRec<?,M>,A,B>
SafeT.Body.Suspended.Φ<M extends MonadRec<?,M>,B,R>
ScanLeft<A,B>	Given an `Iterable` of `A`s, a starting value `B`, and a `Fn2<B, A, B>`, iteratively accumulate over the `Iterable`, collecting each function application result, finally returning an `Iterable` of all the results.
ScanningIterator<A,B>
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.
Semigroup<A>	A `Semigroup` is a closed, associative category.
SemigroupFactory<A,B>
Sequence<A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>>	Given a `Traversable` of `Applicative`s and a pure `Applicative` constructor, traverse the elements from left to right, zipping the `Applicative`s together and collecting the results.
Set<S,T,A,B>	Given an `Optic`, a "smaller" value `B`, and a "larger" value `S`, produce a `T` by lifting the `Optic` into the `Identity` functor.
SetLens	Lenses that operate on `Set`s.
SideEffect	An interface used to represent an effect that requires no input and produces no output, and therefore is only perceivable through inspection of some unreported state.
SingletonHList<_1>	A singleton HList.
Size
Slide<A>	Given an `Iterable<A>`, "slide" a window of `k` elements across the `Iterable` by one element at a time, returning an `Iterable<Iterable<A>>`.
Snoc<A>	Opposite of `Cons`: lazily append an element to the end of the given `Iterable`.
SnocIterable<A>
SnocIterator<A>
Sort<A extends java.lang.Comparable<A>>	Given an `Iterable` of `Comparable` elements, return a `List` of the sorted elements.
SortBy<A,B extends java.lang.Comparable<B>>	Given an `Iterable` and some mapping function from the `Iterable` element type to some `Comparable` type, produce a sorted `List` of the original elements based on sorting applied to the result of the mapping function.
SortWith<A>	Given an `Iterable` and a `Comparator` over the `Iterable` element type, produce a sorted `List` of the original elements based on sorting applied by the `Comparator`.
Span<A>	Given a predicate, return a `Tuple2` where the first slot is the front contiguous elements of an `Iterable` matching the predicate and the second slot is all the remaining elements.
State<S,A>	The state `Monad`, useful for iteratively building up state and state-contextualized result.
StateT<S,M extends MonadRec<?,M>,A>	The `State` `monad transformer`.
Tagged<S,B>	Like `Const`, but the phantom parameter is in the contravariant position, and the value is in covariant position.
Tail<A>	Returns the tail of an `Iterable`; the is, an `Iterable` of all the elements except for the head element.
Tails<A>	Given an `Iterable<A>`, produce an `Iterable<Iterable<A>>`, representing all of the subsequences of tail elements, ordered by size, starting with the full `Iterable`.
Take<A>	Lazily limit the `Iterable` to `n` elements by returning an `Iterable` that stops iteration after the `nth` element, or the last element of the `Iterable`, whichever comes first.
TakeWhile<A>	Lazily limit the `Iterable` to the first group of contiguous elements that satisfy the predicate by iterating up to, but not including, the first element for which the predicate evaluates to `false`.
TakingIterable<A>
TakingIterator<A>
These<A,B>	The coproduct of a coproduct (`CoProduct2<A, B>`) and its product (`Tuple2<A, B>`), represented as a `CoProduct3<A, B, Tuple2<A, B>>`.
These._A<A,B>
These._B<A,B>
These.Both<A,B>
Times<A>	Given some number of times `n` to invoke a function `A -> A`, and given an input `A`, iteratively apply the function to the input, and then to the result of the invocation, a total of `n` times, returning the result.
ToArray<A>	Write all the elements of an `Iterable` directly into an array of the specified type.
ToCollection<A,C extends java.util.Collection<A>>	Given an `Fn0` of some `Collection` `C`, create an instance of `C` and add all of the elements in the provided `Iterable` to the instance.
ToMap<K,V,M extends java.util.Map<K,V>>	Given an `Fn0` of some `Map` `M`, create an instance of `M` and put all of the entries in the provided `Iterable` into the instance.
Trampoline<A,B>	Given an `Fn1<A, CoProduct2<A, B, ?>>` (analogous to "recurse" and "return" tail position instructions, respectively), produce a `Fn1<A, B>` that unrolls the original function by iteratively passing each result that matches the input (`A`) back to the original function, and then terminating on and returning the first output (`B`).
TrampoliningIterator<A,B>
Traversable<A,T extends Traversable<?,T>>	An interface for a class of data structures that can be "traversed from left to right" in a structure-preserving way, successively applying some applicative computation to each element and collapsing the results into a single resulting applicative.
Trivial	The trivial `Unit` `Monoid` formed under `constantly`.
Try<A>	A `Monad` of the evaluation outcome of an expression that might throw.
Try.Failure<A>
Try.Success<A>
Tuple2<_1,_2>	A 2-element tuple product type, implemented as a specialized HList.
Tuple3<_1,_2,_3>	A 3-element tuple product type, implemented as a specialized HList.
Tuple4<_1,_2,_3,_4>	A 4-element tuple product type, implemented as a specialized HList.
Tuple5<_1,_2,_3,_4,_5>	A 5-element tuple product type, implemented as a specialized HList.
Tuple6<_1,_2,_3,_4,_5,_6>	A 6-element tuple product type, implemented as a specialized HList.
Tuple7<_1,_2,_3,_4,_5,_6,_7>	A 7-element tuple product type, implemented as a specialized HList.
Tuple8<_1,_2,_3,_4,_5,_6,_7,_8>	An 8-element tuple product type, implemented as a specialized HList.
Tupler2<A,B>	Creates a `Tuple2` from two values.
TypeSafeKey<A,B>	An interface representing a parametrized key for use in `HMap`s.
TypeSafeKey.Simple<A>	A simplified `TypeSafeKey` that can only view a value of type `A` as an `A`.
Uncons<A>	Destructure an `Iterable` into a `Tuple2` of its head and tail, wrapped in an `Maybe`.
Under<S,T,A,B>	The inverse of `Over`: given an `Iso`, a function from `T` to `S`, and a "smaller" value `B`, return a "smaller" value `A` by traversing around the type ring (`B -> T -> S -> A`).
UnfoldingIterator<A,B>
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 `X`s.
Union<A>	Given two `Iterables` `xs` and `ys`, return the `concatenation` of the `distinct` elements of both `xs` and `ys`.
UnioningIterable<A>
Unit	The empty return type.
Until<A>	Given a `predicate function` for a value of some type `A` and an `IO` that yields a value of type `A`, produce an `IO` that repeatedly executes the original `IO` until the predicate returns true when applied to the yielded value.
Upcast<A extends B,B>	Upcast a value of type `B` to a value of type `A` that `B` extends.
UUIDPrism	`Prisms` for `UUID`.
View<S,T,A,B>	Given an `Optic` and a "larger" value `S`, retrieve a "smaller" value `A` by lifting the `Optic` into the `Const` functor.
Writer<W,A>	The lazy writer monad, a monad capturing some accumulation (eventually to be folded in terms of a given monoid) and a value.
WriterT<W,M extends MonadRec<?,M>,A>	A `monad transformer` for `Writer`.
Xor	Logical exclusive-or.
Zip<A,B>	Zip together two `Iterable`s into a single `Iterable` of `Tuple2<A, B>`.
ZippingIterator<C,A,B>
ZipWith<A,B,C>	Zip together two `Iterable`s by applying a zipping function to the successive elements of each `Iterable` until one of them runs out of elements.