## Uses of Interface
com.jnape.palatable.lambda.monoid.Monoid

- Packages that use Monoid
  Package | Description
  --- | ---
  com.jnape.palatable.lambda.functions.specialized |
  com.jnape.palatable.lambda.functor.builtin |
  com.jnape.palatable.lambda.monad.transformer.builtin |
  com.jnape.palatable.lambda.monoid |
  com.jnape.palatable.lambda.monoid.builtin |

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

    Methods in com.jnape.palatable.lambda.functions.specialized that return Monoid
    Modifier and Type | Method and Description
    --- | ---
    `default Monoid<B>` | MonoidFactory.`apply(A a)`
    `default Monoid<C>` | BiMonoidFactory.`apply(A a, B b)`
    `Monoid<B>` | MonoidFactory.`checkedApply(A a)`
    `Monoid<C>` | BiMonoidFactory.`checkedApply(A a, B b)`

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

    Methods in com.jnape.palatable.lambda.functor.builtin with parameters of type Monoid
    Modifier and Type | Method and Description
    --- | ---
    `Tuple2<A,W>` | Writer.`runWriter(Monoid<W> monoid)` Given a `Monoid` for the accumulation, run the computation represented by this `Writer`, accumulate the written output in terms of the `Monoid`, and produce the accumulation and the value.

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

    Methods in com.jnape.palatable.lambda.monad.transformer.builtin with parameters of type Monoid
    Modifier and Type | Method and Description
    --- | ---
    `<MAW extends MonadRec<Tuple2<A,W>,M>> MAW` | WriterT.`runWriterT(Monoid<W> monoid)` Given a `Monoid` for the accumulation, run the computation represented by this `WriterT` inside the `monadic effect`, accumulate the written output in terms of the `Monoid`, and produce the accumulation and the result inside the `Monad`.

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

    Methods in com.jnape.palatable.lambda.monoid that return Monoid
    Modifier and Type | Method and Description
    --- | ---
    `default Monoid<A>` | Monoid.`flip()` Flip the order of the arguments.
    `static <A> Monoid<A>` | Monoid.`monoid(Semigroup<A> semigroup, A identity)` Promote a `Semigroup` to a `Monoid` by supplying an identity element.
    `static <A> Monoid<A>` | Monoid.`monoid(Semigroup<A> semigroup, Fn0<A> identityFn0)`

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

    Classes in com.jnape.palatable.lambda.monoid.builtin that implement Monoid
    Modifier and Type | Class and Description
    --- | ---
    `class` | `And` A `Monoid` instance formed by `Boolean`.
    `class` | `Concat<A>` The `Monoid` instance formed under concatenation for an arbitrary `Iterable`.
    `class` | `Endo<A>` A `Monoid` formed by `Fn1` under composition.
    `class` | `First<A>` A `Monoid` instance formed by ``Maybe`<A>`.
    `class` | `Join` A `Monoid` instance formed by `String` that concats two strings together.
    `class` | `Last<A>` A `Monoid` instance formed by ``Maybe`<A>`.
    `class` | `Or` A `Monoid` instance formed by `Boolean`.
    `class` | `PutAll` A `Monoid` instance formed by `HMap` that simply combines all the mappings.
    `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.

    Methods in com.jnape.palatable.lambda.monoid.builtin that return Monoid
    Modifier and Type | Method and Description
    --- | ---
    `static <A,C extends Collection<A>> Monoid<C>` | AddAll.`addAll(Fn0<C> collectionFn0)`
    `Monoid<C>` | AddAll.`checkedApply(Fn0<C> cFn0)`
    `Monoid<Map<K,V>>` | MergeMaps.`checkedApply(Fn0<Map<K,V>> mFn0, Semigroup<V> semigroup)`
    `Monoid<Tuple2<_1,_2>>` | Collapse.`checkedApply(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid)`
    `Monoid<IO<A>>` | RunAll.`checkedApply(Monoid<A> monoid)`
    `Monoid<CompletableFuture<A>>` | Compose.`checkedApply(Monoid<A> aMonoid)`
    `Monoid<Either<L,R>>` | LeftAny.`checkedApply(Monoid<L> lMonoid)`
    `Monoid<Either<L,R>>` | LeftAll.`checkedApply(Monoid<L> lMonoid)`
    `Monoid<Either<L,R>>` | RightAny.`checkedApply(Monoid<R> rMonoid)`
    `Monoid<Either<L,R>>` | RightAll.`checkedApply(Monoid<R> rMonoid)`
    `Monoid<Fn1<A,MA>>` | EndoK.`checkedApply(Pure<M> pureM)`
    `Monoid<Maybe<A>>` | Present.`checkedApply(Semigroup<A> aSemigroup)`
    `Monoid<Either<L,R>>` | Merge.`checkedApply(Semigroup<L> lSemigroup, Monoid<R> rMonoid)`
    `static <_1,_2> Monoid<Tuple2<_1,_2>>` | Collapse.`collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid)`
    `static <A> Monoid<CompletableFuture<A>>` | Compose.`compose(Monoid<A> aMonoid)`
    `static <M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>> Monoid<Fn1<A,MA>>` | EndoK.`endoK(Pure<M> pureM)`
    `static <L,R> Monoid<Either<L,R>>` | LeftAll.`leftAll(Monoid<L> lMonoid)`
    `static <L,R> Monoid<Either<L,R>>` | LeftAny.`leftAny(Monoid<L> lMonoid)`
    `static <L,R> Monoid<Either<L,R>>` | Merge.`merge(Semigroup<L> lSemigroup, Monoid<R> rMonoid)`
    `static <K,V> Monoid<Map<K,V>>` | MergeMaps.`mergeMaps(Fn0<Map<K,V>> mFn0, Semigroup<V> semigroup)`
    `static <A> Monoid<Maybe<A>>` | Present.`present(Semigroup<A> semigroup)`
    `static <L,R> Monoid<Either<L,R>>` | RightAll.`rightAll(Monoid<R> rMonoid)`
    `static <L,R> Monoid<Either<L,R>>` | RightAny.`rightAny(Monoid<R> rMonoid)`
    `static <A> Monoid<IO<A>>` | RunAll.`runAll(Monoid<A> monoid)`

    Methods in com.jnape.palatable.lambda.monoid.builtin that return types with arguments of type Monoid
    Modifier and Type | Method and Description
    --- | ---
    `static <_1,_2> MonoidFactory<Monoid<_2>,Tuple2<_1,_2>>` | Collapse.`collapse(Monoid<_1> _1Monoid)`
    `static <L,R> MonoidFactory<Monoid<R>,Either<L,R>>` | Merge.`merge(Semigroup<L> lSemigroup)`

    Methods in com.jnape.palatable.lambda.monoid.builtin with parameters of type Monoid
    Modifier and Type | Method and Description
    --- | ---
    `Monoid<Tuple2<_1,_2>>` | Collapse.`checkedApply(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid)`
    `Monoid<Tuple2<_1,_2>>` | Collapse.`checkedApply(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid)`
    `Monoid<IO<A>>` | RunAll.`checkedApply(Monoid<A> monoid)`
    `Monoid<CompletableFuture<A>>` | Compose.`checkedApply(Monoid<A> aMonoid)`
    `Monoid<Either<L,R>>` | LeftAny.`checkedApply(Monoid<L> lMonoid)`
    `Monoid<Either<L,R>>` | LeftAll.`checkedApply(Monoid<L> lMonoid)`
    `Monoid<Either<L,R>>` | RightAny.`checkedApply(Monoid<R> rMonoid)`
    `Monoid<Either<L,R>>` | RightAll.`checkedApply(Monoid<R> rMonoid)`
    `Monoid<Either<L,R>>` | Merge.`checkedApply(Semigroup<L> lSemigroup, Monoid<R> rMonoid)`
    `static <_1,_2> MonoidFactory<Monoid<_2>,Tuple2<_1,_2>>` | Collapse.`collapse(Monoid<_1> _1Monoid)`
    `static <_1,_2> Monoid<Tuple2<_1,_2>>` | Collapse.`collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid)`
    `static <_1,_2> Monoid<Tuple2<_1,_2>>` | Collapse.`collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid)`
    `static <_1,_2> Fn1<Tuple2<_1,_2>,Tuple2<_1,_2>>` | Collapse.`collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid, Tuple2<_1,_2> x)`
    `static <_1,_2> Fn1<Tuple2<_1,_2>,Tuple2<_1,_2>>` | Collapse.`collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid, Tuple2<_1,_2> x)`
    `static <_1,_2> Tuple2<_1,_2>` | Collapse.`collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid, Tuple2<_1,_2> x, Tuple2<_1,_2> y)`
    `static <_1,_2> Tuple2<_1,_2>` | Collapse.`collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid, Tuple2<_1,_2> x, Tuple2<_1,_2> y)`
    `static <A> Monoid<CompletableFuture<A>>` | Compose.`compose(Monoid<A> aMonoid)`
    `static <A> Fn1<CompletableFuture<A>,CompletableFuture<A>>` | Compose.`compose(Monoid<A> aMonoid, CompletableFuture<A> x)`
    `static <A> CompletableFuture<A>` | Compose.`compose(Monoid<A> aMonoid, CompletableFuture<A> x, CompletableFuture<A> y)`
    `static <L,R> Monoid<Either<L,R>>` | LeftAll.`leftAll(Monoid<L> lMonoid)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | LeftAll.`leftAll(Monoid<L> lMonoid, Either<L,R> x)`
    `static <L,R> Either<L,R>` | LeftAll.`leftAll(Monoid<L> lMonoid, Either<L,R> x, Either<L,R> y)`
    `static <L,R> Monoid<Either<L,R>>` | LeftAny.`leftAny(Monoid<L> lMonoid)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | LeftAny.`leftAny(Monoid<L> lMonoid, Either<L,R> x)`
    `static <L,R> Either<L,R>` | LeftAny.`leftAny(Monoid<L> lMonoid, Either<L,R> x, Either<L,R> y)`
    `static <L,R> Monoid<Either<L,R>>` | Merge.`merge(Semigroup<L> lSemigroup, Monoid<R> rMonoid)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | Merge.`merge(Semigroup<L> lSemigroup, Monoid<R> rMonoid, Either<L,R> x)`
    `static <L,R> Either<L,R>` | Merge.`merge(Semigroup<L> lSemigroup, Monoid<R> rMonoid, Either<L,R> x, Either<L,R> y)`
    `static <L,R> Monoid<Either<L,R>>` | RightAll.`rightAll(Monoid<R> rMonoid)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | RightAll.`rightAll(Monoid<R> rMonoid, Either<L,R> x)`
    `static <L,R> Either<L,R>` | RightAll.`rightAll(Monoid<R> rMonoid, Either<L,R> x, Either<L,R> y)`
    `static <L,R> Monoid<Either<L,R>>` | RightAny.`rightAny(Monoid<R> rMonoid)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | RightAny.`rightAny(Monoid<R> rMonoid, Either<L,R> x)`
    `static <L,R> Either<L,R>` | RightAny.`rightAny(Monoid<R> rMonoid, Either<L,R> x, Either<L,R> y)`
    `static <A> Monoid<IO<A>>` | RunAll.`runAll(Monoid<A> monoid)`
    `static <A> Fn1<IO<A>,IO<A>>` | RunAll.`runAll(Monoid<A> monoid, IO<A> x)`
    `static <A> IO<A>` | RunAll.`runAll(Monoid<A> monoid, IO<A> x, IO<A> y)`