## Uses of Interface
com.jnape.palatable.lambda.monad.Monad

- Packages that use Monad
  Package | Description
  --- | ---
  com.jnape.palatable.lambda.adt |
  com.jnape.palatable.lambda.adt.choice |
  com.jnape.palatable.lambda.adt.hlist |
  com.jnape.palatable.lambda.adt.hmap |
  com.jnape.palatable.lambda.functions |
  com.jnape.palatable.lambda.functions.builtin.fn1 |
  com.jnape.palatable.lambda.functions.builtin.fn2 |
  com.jnape.palatable.lambda.functions.builtin.fn3 |
  com.jnape.palatable.lambda.functions.builtin.fn4 |
  com.jnape.palatable.lambda.functions.builtin.fn5 |
  com.jnape.palatable.lambda.functions.builtin.fn6 |
  com.jnape.palatable.lambda.functions.builtin.fn7 |
  com.jnape.palatable.lambda.functions.builtin.fn8 |
  com.jnape.palatable.lambda.functions.recursion |
  com.jnape.palatable.lambda.functions.specialized |
  com.jnape.palatable.lambda.functor.builtin |
  com.jnape.palatable.lambda.io |
  com.jnape.palatable.lambda.monad |
  com.jnape.palatable.lambda.monad.transformer |
  com.jnape.palatable.lambda.monad.transformer.builtin |
  com.jnape.palatable.lambda.monoid |
  com.jnape.palatable.lambda.monoid.builtin |
  com.jnape.palatable.lambda.optics |
  com.jnape.palatable.lambda.optics.functions |
  com.jnape.palatable.lambda.semigroup |
  com.jnape.palatable.lambda.semigroup.builtin |
  com.jnape.palatable.lambda.traversable |

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

    Classes in com.jnape.palatable.lambda.adt that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Either<L,R>` The binary tagged union, implemented as a specialized `CoProduct2`.
    `class` | `Maybe<A>` The optional type, representing a potentially absent value.
    `class` | `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>>`.
    `class` | `Try<A>` A `Monad` of the evaluation outcome of an expression that might throw.

    Method parameters in com.jnape.palatable.lambda.adt with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `Either<L,R>` | Either.`catchError(Fn1<? super L,? extends Monad<R,Either<L,?>>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `Try<A>` | Try.`catchError(Fn1<? super Throwable,? extends Monad<A,Try<?>>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `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.`flatMap(Fn1<? super A,? extends Monad<B,Maybe<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Try<B>` | Try.`flatMap(Fn1<? super A,? extends Monad<B,Try<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<C> These<A,C>` | These.`flatMap(Fn1<? super B,? extends Monad<C,These<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<R2> Either<L,R2>` | Either.`flatMap(Fn1<? super R,? extends Monad<R2,Either<L,?>>> rightFn)` If a right value, unwrap it and apply it to `rightFn`, returning the resulting `Either<L ,R>`.

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

    Classes in com.jnape.palatable.lambda.adt.choice that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Choice2<A,B>` Canonical ADT representation of `CoProduct2`.
    `class` | `Choice3<A,B,C>` Canonical ADT representation of `CoProduct3`.
    `class` | `Choice4<A,B,C,D>` Canonical ADT representation of `CoProduct4`.
    `class` | `Choice5<A,B,C,D,E>` Canonical ADT representation of `CoProduct5`.
    `class` | `Choice6<A,B,C,D,E,F>` Canonical ADT representation of `CoProduct6`.
    `class` | `Choice7<A,B,C,D,E,F,G>` Canonical ADT representation of `CoProduct7`.
    `class` | `Choice8<A,B,C,D,E,F,G,H>` Canonical ADT representation of `CoProduct8`.

    Method parameters in com.jnape.palatable.lambda.adt.choice with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `<C> Choice2<A,C>` | Choice2.`flatMap(Fn1<? super B,? extends Monad<C,Choice2<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<D> Choice3<A,B,D>` | Choice3.`flatMap(Fn1<? super C,? extends Monad<D,Choice3<A,B,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<E> Choice4<A,B,C,E>` | Choice4.`flatMap(Fn1<? super D,? extends Monad<E,Choice4<A,B,C,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<F> Choice5<A,B,C,D,F>` | Choice5.`flatMap(Fn1<? super E,? extends Monad<F,Choice5<A,B,C,D,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<G> Choice6<A,B,C,D,E,G>` | Choice6.`flatMap(Fn1<? super F,? extends Monad<G,Choice6<A,B,C,D,E,?>>> fn)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<H> Choice7<A,B,C,D,E,F,H>` | Choice7.`flatMap(Fn1<? super G,? extends Monad<H,Choice7<A,B,C,D,E,F,?>>> fn)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`flatMap(Fn1<? super H,? extends Monad<I,Choice8<A,B,C,D,E,F,G,?>>> fn)` Chain dependent computations that may continue or short-circuit based on previous results.

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

    Classes in com.jnape.palatable.lambda.adt.hlist that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SingletonHList<_1>` A singleton HList.
    `class` | `Tuple2<_1,_2>` A 2-element tuple product type, implemented as a specialized HList.
    `class` | `Tuple3<_1,_2,_3>` A 3-element tuple product type, implemented as a specialized HList.
    `class` | `Tuple4<_1,_2,_3,_4>` A 4-element tuple product type, implemented as a specialized HList.
    `class` | `Tuple5<_1,_2,_3,_4,_5>` A 5-element tuple product type, implemented as a specialized HList.
    `class` | `Tuple6<_1,_2,_3,_4,_5,_6>` A 6-element tuple product type, implemented as a specialized HList.
    `class` | `Tuple7<_1,_2,_3,_4,_5,_6,_7>` A 7-element tuple product type, implemented as a specialized HList.
    `class` | `Tuple8<_1,_2,_3,_4,_5,_6,_7,_8>` An 8-element tuple product type, implemented as a specialized HList.

    Method parameters in com.jnape.palatable.lambda.adt.hlist with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `<_1Prime> SingletonHList<_1Prime>` | SingletonHList.`flatMap(Fn1<? super _1,? extends Monad<_1Prime,SingletonHList<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_2Prime> Tuple2<_1,_2Prime>` | Tuple2.`flatMap(Fn1<? super _2,? extends Monad<_2Prime,Tuple2<_1,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_3Prime> Tuple3<_1,_2,_3Prime>` | Tuple3.`flatMap(Fn1<? super _3,? extends Monad<_3Prime,Tuple3<_1,_2,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_4Prime> Tuple4<_1,_2,_3,_4Prime>` | Tuple4.`flatMap(Fn1<? super _4,? extends Monad<_4Prime,Tuple4<_1,_2,_3,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime>` | Tuple5.`flatMap(Fn1<? super _5,? extends Monad<_5Prime,Tuple5<_1,_2,_3,_4,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime>` | Tuple6.`flatMap(Fn1<? super _6,? extends Monad<_6Prime,Tuple6<_1,_2,_3,_4,_5,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>` | Tuple7.`flatMap(Fn1<? super _7,? extends Monad<_7Prime,Tuple7<_1,_2,_3,_4,_5,_6,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>` | Tuple8.`flatMap(Fn1<? super _8,? extends Monad<_8Prime,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.

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

    Subinterfaces of Monad in com.jnape.palatable.lambda.adt.hmap
    Modifier and Type | Interface and 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.
    `interface` | `TypeSafeKey<A,B>` An interface representing a parametrized key for use in `HMap`s.
    `static interface` | `TypeSafeKey.Simple<A>` A simplified `TypeSafeKey` that can only view a value of type `A` as an `A`.

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

    Subinterfaces of Monad in com.jnape.palatable.lambda.functions
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Effect<A>` A function returning "no result", and therefore only useful as a side-effect.
    `interface` | `Fn0<A>` A function taking "no arguments", implemented as an ``Fn1`<`Unit`, A>`.
    `interface` | `Fn1<A,B>` A function taking a single argument.
    `interface` | `Fn2<A,B,C>` A function taking two arguments.
    `interface` | `Fn3<A,B,C,D>` A function taking three arguments.
    `interface` | `Fn4<A,B,C,D,E>` A function taking four arguments.
    `interface` | `Fn5<A,B,C,D,E,F>` A function taking five arguments.
    `interface` | `Fn6<A,B,C,D,E,F,G>` A function taking six arguments.
    `interface` | `Fn7<A,B,C,D,E,F,G,H>` A function taking six arguments.
    `interface` | `Fn8<A,B,C,D,E,F,G,H,I>` A function taking six arguments.

    Method parameters in com.jnape.palatable.lambda.functions with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Fn0<B>` | Fn0.`flatMap(Fn1<? super A,? extends Monad<B,Fn1<Unit,?>>> f)`
    `default <C> Fn1<A,C>` | Fn1.`flatMap(Fn1<? super B,? extends Monad<C,Fn1<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.

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

    Classes in com.jnape.palatable.lambda.functions.builtin.fn1 that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CatMaybes<A>` Given an ``Iterable`<`Maybe`<A>>`, return an ``Iterable`<A>` of only the present values.
    `class` | `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.
    `class` | `Constantly<A,B>` A function that takes two arguments and always returns the first argument.
    `class` | `Cycle<A>` Given an `Iterable`, return an infinite `Iterable` that repeatedly cycles its elements, in order.
    `class` | `Distinct<A>` Return an `Iterable` of the distinct values from the given input `Iterable`.
    `class` | `Downcast<A extends B,B>` Covariantly cast a value of type `B` to a value of subtype `A`.
    `class` | `Empty<A>` A predicate that returns true if `as` is empty; false otherwise.
    `class` | `Flatten<A>` Given a nested `Iterable` of `Iterable`s, return a lazily flattening `Iterable` of the nested elements.
    `class` | `Force<A>` Deprecated. in favor of `traversing` into an `IO` and running it
    `class` | `Head<A>` Retrieve the head element of an `Iterable`, wrapped in an `Maybe`.
    `class` | `Id<A>` The identity function.
    `class` | `Init<A>` Given an ``Iterable`<A>`, produce an ``Iterable`<A>` of all elements but the last one.
    `class` | `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`.
    `class` | `Last<A>` Retrieve the last element of an `Iterable`, wrapped in a `Maybe`.
    `class` | `Magnetize<A>` `Magnetize` an `Iterable` using value equality as the magnetizing function.
    `class` | `Not<A>` Negate a predicate function.
    `class` | `Occurrences<A>` Given an ``Iterable`<A>`, return a ``Map`<A, Long>` representing each unique element in the `Iterable` paired with its number of occurrences.
    `class` | `Repeat<A>` Given a value, return an infinite `Iterable` that repeatedly iterates that value.
    `class` | `Reverse<A>` Given an `Iterable`, return a reversed representation of that `Iterable`.
    `class` | `Size`
    `class` | `Sort<A extends Comparable<A>>` Given an `Iterable` of `Comparable` elements, return a `List` of the sorted elements.
    `class` | `Tail<A>` Returns the tail of an `Iterable`; the is, an `Iterable` of all the elements except for the head element.
    `class` | `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`.
    `class` | `Uncons<A>` Destructure an `Iterable` into a `Tuple2` of its head and tail, wrapped in an `Maybe`.
    `class` | `Upcast<A extends B,B>` Upcast a value of type `B` to a value of type `A` that `B` extends.

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

    Classes in com.jnape.palatable.lambda.functions.builtin.fn2 that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `All<A>` Eagerly apply a predicate to each element in an `Iterable`, returning `true` if every element satisfies the predicate, and `false` otherwise.
    `class` | `Alter<A>` Given an ``Effect`<A>` and some `A`, produce an `IO` that, when run, performs the effect on `A` and returns it.
    `class` | `Any<A>` Eagerly apply a predicate to each element in an `Iterable`, returning `true` if any element satisfies the predicate, and `false` otherwise.
    `class` | `AutoBracket<A extends 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.
    `class` | `Both<A,B,C>` Given two functions `f` and `g`, produce a ``Fn1`<A, `Tuple2`<B, C>>` (the dual application of both functions).
    `class` | `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.
    `class` | `CmpEq<A extends 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.
    `class` | `Cons<A>` Prepend an element to an `Iterable`.
    `class` | `Difference<A>` Given two `Iterables` `xs` and `ys`, return the `distinct` elements of `xs` that are not in `ys`.
    `class` | `Drop<A>` Lazily skip the first `n` elements from an `Iterable` by returning an `Iterable` that begins iteration after the `nth` element.
    `class` | `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`.
    `class` | `Eq<A>` Type-safe equality in function form; uses `Object.equals(java.lang.Object)`, not `==`.
    `class` | `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`.
    `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`.
    `class` | `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.
    `class` | `GT<A extends 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.
    `class` | `GTE<A extends 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.
    `class` | `InGroupsOf<A>` Lazily group the `Iterable` by returning an `Iterable` of smaller `Iterable`s of size `k`.
    `class` | `Intersperse<A>` Lazily inject the provided separator value between each value in the supplied `Iterable`.
    `class` | `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.
    `class` | `Into1<A,B>` Given an ``Fn1`<A, B>` and a ``SingletonHList`<A>`, pop the head and apply it to the function, returning the result.
    `class` | `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.
    `class` | `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.
    `class` | `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.
    `class` | `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.
    `class` | `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.
    `class` | `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.
    `class` | `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, ...`
    `class` | `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.
    `class` | `LT<A extends 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.
    `class` | `LTE<A extends 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.
    `class` | `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.
    `class` | `Map<A,B>` Lazily apply a function to each element in an `Iterable`, producing an `Iterable` of the mapped results.
    `class` | `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.
    `class` | `Peek<A,FA extends Functor<A,?>>` Deprecated. in favor of producing an `IO` from the given `Functor` and explicitly running it
    `class` | `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
    `class` | `PrependAll<A>` Lazily prepend each value with of the `Iterable` with the supplied separator value.
    `class` | `ReduceLeft<A>` Given an ``Iterable`<A>` and a ``Fn2`<A, A, A>`, iteratively accumulate over the `Iterable`, returning ``Maybe`<A>`.
    `class` | `ReduceRight<A>` Given an ``Iterable`<A>` and a ``Fn2`<A, A, A>`, iteratively accumulate over the `Iterable`, returning ``Maybe`<A>`.
    `class` | `Replicate<A>` Produce an `Iterable` of a value `n` times.
    `class` | `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.
    `class` | `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>>`.
    `class` | `Snoc<A>` Opposite of `Cons`: lazily append an element to the end of the given `Iterable`.
    `class` | `SortBy<A,B extends 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.
    `class` | `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`.
    `class` | `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.
    `class` | `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.
    `class` | `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`.
    `class` | `ToArray<A>` Write all the elements of an `Iterable` directly into an array of the specified type.
    `class` | `ToCollection<A,C extends 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.
    `class` | `ToMap<K,V,M extends 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.
    `class` | `Tupler2<A,B>` Creates a `Tuple2` from two values.
    `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 `X`s.
    `class` | `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.
    `class` | `Zip<A,B>` Zip together two `Iterable`s into a single `Iterable` of `Tuple2<A, B>`.

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

    Classes in com.jnape.palatable.lambda.functions.builtin.fn3 that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Between<A extends 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.
    `class` | `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.
    `class` | `Clamp<A extends 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
    `class` | `CmpEqBy<A,B extends 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.
    `class` | `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.
    `class` | `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.
    `class` | `GTBy<A,B extends 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.
    `class` | `GTEBy<A,B extends 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.
    `class` | `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.
    `class` | `LTBy<A,B extends 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.
    `class` | `LTEBy<A,B extends 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.
    `class` | `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.
    `class` | `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.
    `class` | `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.

  - ### Uses of Monad in com.jnape.palatable.lambda.functions.builtin.fn4

    Classes in com.jnape.palatable.lambda.functions.builtin.fn4 that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `IfThenElse<A,B>`
    `class` | `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.
    `class` | `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.

  - ### Uses of Monad in com.jnape.palatable.lambda.functions.builtin.fn5

    Classes in com.jnape.palatable.lambda.functions.builtin.fn5 that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `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.

  - ### Uses of Monad in com.jnape.palatable.lambda.functions.builtin.fn6

    Classes in com.jnape.palatable.lambda.functions.builtin.fn6 that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `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.

  - ### Uses of Monad in com.jnape.palatable.lambda.functions.builtin.fn7

    Classes in com.jnape.palatable.lambda.functions.builtin.fn7 that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `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.

  - ### Uses of Monad in com.jnape.palatable.lambda.functions.builtin.fn8

    Classes in com.jnape.palatable.lambda.functions.builtin.fn8 that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `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.

  - ### Uses of Monad in com.jnape.palatable.lambda.functions.recursion

    Classes in com.jnape.palatable.lambda.functions.recursion that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `RecursiveResult<A,B>` Specialized `CoProduct2` representing the possible results of a primitive recursive function.
    `class` | `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`).

    Method parameters in com.jnape.palatable.lambda.functions.recursion with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `<C> RecursiveResult<A,C>` | RecursiveResult.`flatMap(Fn1<? super B,? extends Monad<C,RecursiveResult<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.

  - ### Uses of Monad in com.jnape.palatable.lambda.functions.specialized

    Classes in com.jnape.palatable.lambda.functions.specialized with type parameters of type Monad
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `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>`.
    `interface` | `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>`.

    Subinterfaces of Monad in com.jnape.palatable.lambda.functions.specialized
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BiMonoidFactory<A,B,C>`
    `interface` | `BiPredicate<A,B>` A specialized `Fn2` that returns a Boolean when fully applied, or a `Predicate` when partially applied.
    `interface` | `BiSemigroupFactory<A,B,C>`
    `interface` | `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>`.
    `interface` | `MonoidFactory<A,B>`
    `interface` | `Predicate<A>` A specialized `Fn1` that returns a `Boolean`.
    `interface` | `SemigroupFactory<A,B>`

    Methods in com.jnape.palatable.lambda.functions.specialized with type parameters of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `default <C,MC extends Monad<C,M>> Kleisli<A,C,M,MC>` | Kleisli.`andThen(Kleisli<B,C,M,MC> after)` Left-to-right composition of two compatible `Kleisli` arrows, yielding a new `Kleisli` arrow.
    `default <Z,MA extends Monad<A,M>> Kleisli<Z,B,M,MB>` | Kleisli.`compose(Kleisli<Z,A,M,MA> before)` Right-to-left composition of two compatible `Kleisli` arrows, yielding a new `Kleisli` arrow.
    `static <A,B,M extends Monad<?,M>,MB extends Monad<B,M>> Kleisli<A,B,M,MB>` | Kleisli.`kleisli(Fn1<? super A,? extends MB> fn)` Adapt a compatible function into a `Kleisli` arrow.
    `static <A,B,M extends Monad<?,M>,MB extends Monad<B,M>> Kleisli<A,B,M,MB>` | Kleisli.`kleisli(Fn1<? super A,? extends MB> fn)` Adapt a compatible function into a `Kleisli` arrow.

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

    Classes in com.jnape.palatable.lambda.functor.builtin that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Const<A,B>` A (surprisingly useful) functor over some phantom type `B`, retaining a value of type `A` that can be retrieved later.
    `class` | `Identity<A>` A functor over some value of type `A` that can be mapped over and retrieved later.
    `class` | `Lazy<A>` A `Monad` representing a lazily-computed value.
    `class` | `Market<A,B,S,T>` A profunctor used to extract the isomorphic functions a `Prism` is composed of.
    `class` | `State<S,A>` The state `Monad`, useful for iteratively building up state and state-contextualized result.
    `class` | `Tagged<S,B>` Like `Const`, but the phantom parameter is in the contravariant position, and the value is in covariant position.
    `class` | `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.

    Method parameters in com.jnape.palatable.lambda.functor.builtin with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `<B> Identity<B>` | Identity.`flatMap(Fn1<? super A,? extends Monad<B,Identity<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Lazy<B>` | Lazy.`flatMap(Fn1<? super A,? extends Monad<B,Lazy<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> State<S,B>` | State.`flatMap(Fn1<? super A,? extends Monad<B,State<S,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Writer<W,B>` | Writer.`flatMap(Fn1<? super A,? extends Monad<B,Writer<W,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<C> Const<A,C>` | Const.`flatMap(Fn1<? super B,? extends Monad<C,Const<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<C> Tagged<S,C>` | Tagged.`flatMap(Fn1<? super B,? extends Monad<C,Tagged<S,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<U> Market<A,B,S,U>` | Market.`flatMap(Fn1<? super T,? extends Monad<U,Market<A,B,S,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.

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

    Classes in com.jnape.palatable.lambda.io that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `IO<A>` A `Monad` representing some side-effecting computation to be performed.

    Method parameters in com.jnape.palatable.lambda.io with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `IO<A>` | IO.`catchError(Fn1<? super Throwable,? extends Monad<A,IO<?>>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `<B> IO<B>` | IO.`flatMap(Fn1<? super A,? extends Monad<B,IO<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.

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

    Classes in com.jnape.palatable.lambda.monad with type parameters of type Monad
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Monad<A,M extends Monad<?,M>>` Monads are `Applicative` functors that support a flattening operation to unwrap `M<M<A>> -> M<A>`.

    Subinterfaces of Monad in com.jnape.palatable.lambda.monad
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `MonadError<E,A,M extends MonadError<E,?,M>>` An interface for `monads` that can be interrupted with some type of error.
    `interface` | `MonadReader<R,A,MR extends MonadReader<R,?,MR>>` A monad that is capable of reading an environment `R` and producing a lifted value `A`.
    `interface` | `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)`.
    `interface` | `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.

    Classes in com.jnape.palatable.lambda.monad that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `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`.

    Methods in com.jnape.palatable.lambda.monad with type parameters of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `static <M extends Monad<?,M>,A,MA extends Monad<A,M>> MA` | Monad.`join(Monad<? extends MA,M> mma)` Convenience static method equivalent to `flatMap``(id())`;
    `static <M extends Monad<?,M>,A,MA extends Monad<A,M>> MA` | Monad.`join(Monad<? extends MA,M> mma)` Convenience static method equivalent to `flatMap``(id())`;

    Methods in com.jnape.palatable.lambda.monad that return Monad
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Monad<B,M>` | Monad.`discardL(Applicative<B,M> appB)` Sequence both this `Applicative` and `appB`, discarding this `Applicative's` result and returning `appB`.
    `default <B> Monad<A,M>` | Monad.`discardR(Applicative<B,M> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `<B> Monad<B,M>` | Monad.`flatMap(Fn1<? super A,? extends Monad<B,M>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <B> Monad<B,M>` | Monad.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> Monad<B,M>` | Monad.`pure(B b)` Lift the value `b` into this applicative functor.
    `default <B> Monad<B,M>` | Monad.`zip(Applicative<Fn1<? super A,? extends B>,M> 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.monad that return types with arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Lazy<? extends Monad<B,M>>` | Monad.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> lazyAppFn)` Given a `lazy` instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

    Methods in com.jnape.palatable.lambda.monad with parameters of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `static <M extends Monad<?,M>,A,MA extends Monad<A,M>> MA` | Monad.`join(Monad<? extends MA,M> mma)` Convenience static method equivalent to `flatMap``(id())`;

    Method parameters in com.jnape.palatable.lambda.monad with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `MonadError<E,A,M>` | MonadError.`catchError(Fn1<? super E,? extends Monad<A,M>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `<B> MonadError<E,B,M>` | MonadError.`flatMap(Fn1<? super A,? extends Monad<B,M>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Monad<B,M>` | Monad.`flatMap(Fn1<? super A,? extends Monad<B,M>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> MonadRec<B,M>` | MonadRec.`flatMap(Fn1<? super A,? extends Monad<B,M>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> MonadReader<R,B,MR>` | MonadReader.`flatMap(Fn1<? super A,? extends Monad<B,MR>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> MonadWriter<W,B,MW>` | MonadWriter.`flatMap(Fn1<? super A,? extends Monad<B,MW>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> SafeT<M,B>` | SafeT.`flatMap(Fn1<? super A,? extends Monad<B,SafeT<M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.

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

    Subinterfaces of Monad in com.jnape.palatable.lambda.monad.transformer
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `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.

    Method parameters in com.jnape.palatable.lambda.monad.transformer with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `<B> MonadT<M,B,MT,T>` | MonadT.`flatMap(Fn1<? super A,? extends Monad<B,MT>> f)` Chain dependent computations that may continue or short-circuit based on previous results.

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

    Classes in com.jnape.palatable.lambda.monad.transformer.builtin that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `EitherT<M extends MonadRec<?,M>,L,R>` A `monad transformer` for `Either`.
    `class` | `IdentityT<M extends MonadRec<?,M>,A>` A `monad transformer` for `Identity`.
    `class` | `LazyT<M extends MonadRec<?,M>,A>` A `monad transformer` for `Lazy`.
    `class` | `MaybeT<M extends MonadRec<?,M>,A>` A `monad transformer` for `Maybe`.
    `class` | `ReaderT<R,M extends MonadRec<?,M>,A>` A `monad transformer` for any `function` from some type `R` to some `monadic` embedding ``MonadRec`<A, M>`.
    `class` | `StateT<S,M extends MonadRec<?,M>,A>` The `State` `monad transformer`.
    `class` | `WriterT<W,M extends MonadRec<?,M>,A>` A `monad transformer` for `Writer`.

    Methods in com.jnape.palatable.lambda.monad.transformer.builtin with type parameters of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `<MA extends Monad<A,M>> MA` | StateT.`evalT(S s)` Run the stateful computation embedded in the `Monad`, returning the result.
    `<MS extends Monad<S,M>> MS` | StateT.`execT(S s)` Run the stateful computation embedded in the `Monad`, returning the final state.

    Method parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `<B> IdentityT<M,B>` | IdentityT.`flatMap(Fn1<? super A,? extends Monad<B,IdentityT<M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> LazyT<M,B>` | LazyT.`flatMap(Fn1<? super A,? extends Monad<B,LazyT<M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> MaybeT<M,B>` | MaybeT.`flatMap(Fn1<? super A,? extends Monad<B,MaybeT<M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> ReaderT<R,M,B>` | ReaderT.`flatMap(Fn1<? super A,? extends Monad<B,ReaderT<R,M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> StateT<S,M,B>` | StateT.`flatMap(Fn1<? super A,? extends Monad<B,StateT<S,M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> WriterT<W,M,B>` | WriterT.`flatMap(Fn1<? super A,? extends Monad<B,WriterT<W,M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<R2> EitherT<M,L,R2>` | EitherT.`flatMap(Fn1<? super R,? extends Monad<R2,EitherT<M,L,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.

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

    Subinterfaces of Monad in com.jnape.palatable.lambda.monoid
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Monoid<A>` A `Monoid` is the pairing of a `Semigroup` with an identity element.

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

    Classes in com.jnape.palatable.lambda.monoid.builtin that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AddAll<A,C extends Collection<A>>` The `Monoid` instance formed under mutative concatenation for an arbitrary `Collection`.
    `class` | `And` A `Monoid` instance formed by `Boolean`.
    `class` | `Collapse<_1,_2>` A `Monoid` instance formed by a ``Tuple2`<_1, _2>` and monoids over `_1` and `_2`.
    `class` | `Compose<A>` A `Monoid` instance formed by ``CompletableFuture`<A>` and a monoid over `A`.
    `class` | `Concat<A>` The `Monoid` instance formed under concatenation for an arbitrary `Iterable`.
    `class` | `Endo<A>` A `Monoid` formed by `Fn1` under composition.
    `class` | `EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>` The monoid formed under monadic endomorphism.
    `class` | `First<A>` A `Monoid` instance formed by ``Maybe`<A>`.
    `class` | `Join` A `Monoid` instance formed by `String` that concats two strings together.
    `class` | `LeftAll<L,R>` A `Monoid` instance formed by ``Either`<L,R>` and a monoid over `L`.
    `class` | `LeftAny<L,R>` A `Monoid` instance formed by ``Either`<L,R>` and a monoid over `L`.
    `class` | `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`.
    `class` | `MergeMaps<K,V>` A `Monoid` instance formed by `Map.merge(Object, Object, BiFunction)` and a semigroup over `V`.
    `class` | `Or` A `Monoid` instance formed by `Boolean`.
    `class` | `Present<A>` A `Monoid` instance formed by ``Maybe`<A>` and a semigroup over `A`.
    `class` | `PutAll` A `Monoid` instance formed by `HMap` that simply combines all the mappings.
    `class` | `RightAll<L,R>` A `Monoid` instance formed by ``Either`<L,R>` and a monoid over `R`.
    `class` | `RightAny<L,R>` A `Monoid` instance formed by ``Either`<L,R>` and a monoid over `R`.
    `class` | `RunAll<A>` Run `IO` operations, aggregating their results in terms of the provided `Monoid`.
    `class` | `Trivial` The trivial `Unit` `Monoid` formed under `constantly`.
    `class` | `Union<A>` Given two `Iterables` `xs` and `ys`, return the `concatenation` of the `distinct` elements of both `xs` and `ys`.
    `class` | `Xor` Logical exclusive-or.

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

    Subinterfaces of Monad in com.jnape.palatable.lambda.optics
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `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 ``Lens`es`, can be ``View`ed`, `Set`, and ``updated``.
    `static interface` | `Iso.Simple<S,A>` A convenience type with a simplified type signature for common isos with both unified "larger" values and unified "smaller" values.
    `interface` | `Lens<S,T,A,B>` An approximation of van Laarhoven lenses.
    `static interface` | `Lens.Simple<S,A>` A convenience type with a simplified type signature for common lenses with both unified "larger" values and unified "smaller" values.
    `interface` | `Prism<S,T,A,B>` Prisms are `Isos` that can fail in one direction.
    `static interface` | `Prism.Simple<S,A>` A convenience type with a simplified type signature for common `prism` with unified `S/T` and `A/B` types.

    Method parameters in com.jnape.palatable.lambda.optics with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `default <U> Iso<S,U,A,B>` | Iso.`flatMap(Fn1<? super T,? extends Monad<U,Iso<S,?,A,B>>> fn)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <U> Lens<S,U,A,B>` | Lens.`flatMap(Fn1<? super T,? extends Monad<U,Lens<S,?,A,B>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <U> Prism<S,U,A,B>` | Prism.`flatMap(Fn1<? super T,? extends Monad<U,Prism<S,?,A,B>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.

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

    Classes in com.jnape.palatable.lambda.optics.functions that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Matching<S,T,A,B>`
    `class` | `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.
    `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.
    `class` | `Re<S,T,A,B>` Turn an `Optic` with a unary mapping that can be used for setting (e.g.
    `class` | `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.
    `class` | `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`).
    `class` | `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.

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

    Subinterfaces of Monad in com.jnape.palatable.lambda.semigroup
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Semigroup<A>` A `Semigroup` is a closed, associative category.

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

    Classes in com.jnape.palatable.lambda.semigroup.builtin that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Absent<A>` A `Semigroup` instance formed by ``Maybe`<A>` and a semigroup over `A`.
    `class` | `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`.
    `class` | `Max<A extends 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`
    `class` | `MaxBy<A,B extends 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`
    `class` | `Min<A extends 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`
    `class` | `MinBy<A,B extends 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`

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

    Classes in com.jnape.palatable.lambda.traversable that implement Monad
    Modifier and Type | Class and Description
    --- | ---
    `class` | `LambdaIterable<A>` Extension point for `Iterable` to adapt lambda core types like `Monad` and `Traversable`.

    Method parameters in com.jnape.palatable.lambda.traversable with type arguments of type Monad
    Modifier and Type | Method and Description
    --- | ---
    `<B> LambdaIterable<B>` | LambdaIterable.`flatMap(Fn1<? super A,? extends Monad<B,LambdaIterable<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.