Monoids (cyclops-react 2.0.0-MI6 API)

```
public interface Monoids
```
A static class with a large number of Monoids or Combiners with identity elements. A Monoid is an Object that can be used toNested combine objects of the same type inconjunction with it's identity element which leaves any element it is combined with unchanged.

Field Summary

Fields
Modifier and Type	Field and Description
`static Monoid<java.math.BigInteger>`	`bigIntCount` Combine two BigIntegers by adding one toNested a (can be used toNested count BigIntegers in a Collection or Stream)
`static Monoid<java.math.BigInteger>`	`bigIntMax` Combine two BigIntegers by selecting the max
`static Monoid<java.math.BigInteger>`	`bigIntMin` Combine two BigIntegers by selecting the min
`static Monoid<java.math.BigInteger>`	`bigIntMult` Combine two BigIntegers by multiplying them
`static Monoid<java.math.BigInteger>`	`bigIntSum` Combine two BigIngegers by summing them
`static Monoid<java.lang.Boolean>`	`booleanConjunction` Combine two booleans by AND'ing them (conjunction)
`static Monoid<java.lang.Boolean>`	`booleanDisjunction` Combine two booleans by OR'ing them (disjunction)
`static Monoid<java.lang.Boolean>`	`booleanXDisjunction` Combine two booleans by XOR'ing them (exclusive disjunction)
`static Monoid<java.lang.Double>`	`doubleCount` Combine two Double by adding one toNested a (can be used toNested count Double in a Collection or Stream)
`static Monoid<java.lang.Double>`	`doubleMax` Combine two Doubles by selecting the max
`static Monoid<java.lang.Double>`	`doubleMin` Combine two Doubles by selecting the min
`static Monoid<java.lang.Double>`	`doubleMult` Combine two Doubles by multiplying them
`static Monoid<java.lang.Double>`	`doubleSum` Combine two Doubles by summing them
`static Monoid<java.lang.Integer>`	`intCount` Combine two Integers by adding one toNested a (can be used toNested count Integers in a Collection or Stream)
`static Monoid<java.lang.Integer>`	`intMax` Combine two Integers by selecting the max
`static Monoid<java.lang.Integer>`	`intMin` Combine two Integers by selecting the min
`static Monoid<java.lang.Integer>`	`intMult` Combine two Integers by multiplying them
`static Monoid<java.lang.Integer>`	`intSum` Combine two Integers by summing them
`static Monoid<java.lang.Long>`	`longCount` Combine two Longs by adding one toNested a (can be used toNested count Integers in a Collection or Stream)
`static Monoid<java.lang.Long>`	`longMax` Combine two Longs by selecting the max
`static Monoid<java.lang.Long>`	`longMin` Combine two Longs by selecting the min
`static Monoid<java.lang.Long>`	`longMult` Combine two Longs by multiplying them
`static Monoid<java.lang.Long>`	`longSum` Combine two Longs by summing them
`static Monoid<java.lang.StringBuffer>`	`stringBufferConcat` StringBuffer concatenation
`static Monoid<java.lang.StringBuilder>`	`stringBuilderConcat` StringBuilder concatenation
`static Monoid<java.lang.String>`	`stringConcat` String concatenation

Method Summary

All Methods Static Methods Default Methods
Modifier and Type	Method and Description
`static <T> Monoid<org.reactivestreams.Publisher<T>>`	`amb()`
`static <T> Monoid<ReactiveSeq<T>>`	`ambReactiveSeq()`
`static <T> Monoid<BagX<T>>`	`bagXConcat()`
`static <T,C extends java.util.Collection<T>> Monoid<C>`	`collectionConcat(C zero)` This Semigroup will attempt toNested combine JDK Collections.
`static <T,C extends FluentCollectionX<T>> Monoid<C>`	`collectionXConcat(C identity)` To manage javac type inference first assign the monoid
`static <T> Semigroup<FutureStream<T>>`	`combineFutureStream()`
`static <T> Monoid<ReactiveSeq<T>>`	`combineReactiveSeq()`
`static <T,A extends Zippable<T>> Monoid<A>`	`combineScalarFunctors(java.util.function.Function<T,A> zeroFn, Monoid<T> monoid)` Example sum integer Maybes
`static <T> Monoid<org.jooq.lambda.Seq<T>>`	`combineSeq()`
`static <T> Monoid<java.util.stream.Stream<T>>`	`combineStream()`
`static <T,A extends Zippable<T>> Monoid<A>`	`combineZippables(java.util.function.Function<T,A> zeroFn, Monoid<T> monoid)` Example sum integer Lists
`static <T> Monoid<DequeX<T>>`	`dequeXConcat()`
`static <T> Monoid<java.util.concurrent.CompletableFuture<T>>`	`firstCompleteCompletableFuture()`
`static <T> Monoid<Future<T>>`	`firstCompleteFuture()`
`static <T,C extends java.util.Collection<T>> Monoid<C>`	`firstNonEmpty(C zero)`
`static <T> Monoid<ReactiveSeq<T>>`	`firstNonEmptyReactiveSeq()`
`static <T> Monoid<T>`	`firstNonNull()`
`static <T> Monoid<SimpleReactStream<T>>`	`firstOfSimpleReact()`
`static <T> Monoid<Maybe<T>>`	`firstPresentMaybe()`
`static <T> Monoid<java.util.Optional<T>>`	`firstPresentOptional()`
`static <ST,PT> Monoid<Ior<ST,PT>>`	`firstPrimaryIor(ST zero)`
`static <ST,PT> Monoid<Xor<ST,PT>>`	`firstPrimaryXor(ST zero)`
`static <ST,PT> Monoid<Ior<ST,PT>>`	`firstSecondaryIor(PT zero)`
`static <ST,PT> Monoid<Xor<ST,PT>>`	`firstSecondaryXor(PT zero)`
`static <T> Monoid<Future<T>>`	`firstSuccessfulFuture()`
`static <T,X extends java.lang.Throwable> Monoid<Try<T,X>>`	`firstTryFailure(T zero)`
`static <T,X extends java.lang.Throwable> Monoid<Try<T,X>>`	`firstTrySuccess(X zero)`
`static <A> Monoid<java.util.function.Function<A,A>>`	`functionComposition()`
`static <T,C extends java.util.Collection<T>> Monoid<C>`	`lastNonEmpty(C zero)`
`static <T> Monoid<Maybe<T>>`	`lastPresentMaybe()`
`static <T> Monoid<java.util.Optional<T>>`	`lastPresentOptional()`
`static <ST,PT> Monoid<Ior<ST,PT>>`	`lastPrimaryIor(ST zero)`
`static <ST,PT> Monoid<Xor<ST,PT>>`	`lastPrimaryXor(ST zero)`
`static <ST,PT> Monoid<Ior<ST,PT>>`	`lastSecondaryIor(PT zero)`
`static <ST,PT> Monoid<Xor<ST,PT>>`	`lastSecondaryXor(PT zero)`
`static <T,X extends java.lang.Throwable> Monoid<Try<T,X>>`	`lastTryFailure(T zero)`
`static <T,X extends java.lang.Throwable> Monoid<Try<T,X>>`	`lastTrySuccess(X zero)`
`static <T> Monoid<LinkedListX<T>>`	`linkedListXConcat()`
`static <T> Monoid<ListX<T>>`	`listXConcat()`
`static <T,T2 extends java.lang.Comparable<T>> Monoid<T2>`	`maxComparable(T2 min)`
`static <T> Monoid<org.reactivestreams.Publisher<T>>`	`mergeLatest()`
`static <T> Monoid<ReactiveSeq<T>>`	`mergeLatestReactiveSeq()`
`static <T,T2 extends java.lang.Comparable<T>> Monoid<T2>`	`minComparable(T2 max)`
`static <T,C extends java.util.Collection<T>> Monoid<C>`	`mutableCollectionConcat(C identity)` Concatenate mutable collections To manage javac type inference first assign the Monoid
`static <T> Monoid<java.util.Deque<T>>`	`mutableDequeConcat()`
`static <T> Monoid<java.util.List<T>>`	`mutableListConcat()`
`static <T> Monoid<java.util.Queue<T>>`	`mutableQueueConcat()`
`static <T> Monoid<java.util.Set<T>>`	`mutableSetConcat()`
`static <T> Monoid<java.util.SortedSet<T>>`	`mutableSortedSetConcat()`
`static <T> Monoid<OrderedSetX<T>>`	`orderedSetXConcat()`
`static <T> Monoid<PersistentQueueX<T>>`	`persistentQueueXConcat()`
`static <T> Monoid<PersistentSetX<T>>`	`persistentSetXConcat()`
`static <T> Monoid<QueueX<T>>`	`queueXConcat()`
`static <T> Monoid<SetX<T>>`	`setXConcat()`
`static <T> Monoid<SortedSetX<T>>`	`sortedSetXConcat()`
`static Monoid<java.lang.StringBuffer>`	`stringBufferJoin(java.lang.String joiner)`
`static Monoid<java.lang.StringBuilder>`	`stringBuilderJoin(java.lang.String joiner)`
`static Monoid<java.lang.String>`	`stringJoin(java.lang.String joiner)`
`static <T> Monoid<VectorX<T>>`	`vectorXConcat()`

- Field Detail
  - bigIntCount
```
static final Monoid<java.math.BigInteger> bigIntCount
```
    Combine two BigIntegers by adding one toNested a (can be used toNested count BigIntegers in a Collection or Stream)
  - intCount
```
static final Monoid<java.lang.Integer> intCount
```
    Combine two Integers by adding one toNested a (can be used toNested count Integers in a Collection or Stream)
  - longCount
```
static final Monoid<java.lang.Long> longCount
```
    Combine two Longs by adding one toNested a (can be used toNested count Integers in a Collection or Stream)
  - doubleCount
```
static final Monoid<java.lang.Double> doubleCount
```
    Combine two Double by adding one toNested a (can be used toNested count Double in a Collection or Stream)
  - intSum
```
static final Monoid<java.lang.Integer> intSum
```
    Combine two Integers by summing them
  - longSum
```
static final Monoid<java.lang.Long> longSum
```
    Combine two Longs by summing them
  - doubleSum
```
static final Monoid<java.lang.Double> doubleSum
```
    Combine two Doubles by summing them
  - bigIntSum
```
static final Monoid<java.math.BigInteger> bigIntSum
```
    Combine two BigIngegers by summing them
  - intMult
```
static final Monoid<java.lang.Integer> intMult
```
    Combine two Integers by multiplying them
  - longMult
```
static final Monoid<java.lang.Long> longMult
```
    Combine two Longs by multiplying them
  - doubleMult
```
static final Monoid<java.lang.Double> doubleMult
```
    Combine two Doubles by multiplying them
  - bigIntMult
```
static final Monoid<java.math.BigInteger> bigIntMult
```
    Combine two BigIntegers by multiplying them
  - intMax
```
static final Monoid<java.lang.Integer> intMax
```
    Combine two Integers by selecting the max
  - longMax
```
static final Monoid<java.lang.Long> longMax
```
    Combine two Longs by selecting the max
  - doubleMax
```
static final Monoid<java.lang.Double> doubleMax
```
    Combine two Doubles by selecting the max
  - bigIntMax
```
static final Monoid<java.math.BigInteger> bigIntMax
```
    Combine two BigIntegers by selecting the max
  - intMin
```
static final Monoid<java.lang.Integer> intMin
```
    Combine two Integers by selecting the min
  - longMin
```
static final Monoid<java.lang.Long> longMin
```
    Combine two Longs by selecting the min
  - doubleMin
```
static final Monoid<java.lang.Double> doubleMin
```
    Combine two Doubles by selecting the min
  - bigIntMin
```
static final Monoid<java.math.BigInteger> bigIntMin
```
    Combine two BigIntegers by selecting the min
  - stringConcat
```
static final Monoid<java.lang.String> stringConcat
```
    String concatenation
  - stringBufferConcat
```
static final Monoid<java.lang.StringBuffer> stringBufferConcat
```
    StringBuffer concatenation
  - stringBuilderConcat
```
static final Monoid<java.lang.StringBuilder> stringBuilderConcat
```
    StringBuilder concatenation
  - booleanDisjunction
```
static final Monoid<java.lang.Boolean> booleanDisjunction
```
    Combine two booleans by OR'ing them (disjunction)
  - booleanXDisjunction
```
static final Monoid<java.lang.Boolean> booleanXDisjunction
```
    Combine two booleans by XOR'ing them (exclusive disjunction)
  - booleanConjunction
```
static final Monoid<java.lang.Boolean> booleanConjunction
```
    Combine two booleans by AND'ing them (conjunction)
- Method Detail
  - collectionXConcat
```
static <T,C extends FluentCollectionX<T>> Monoid<C> collectionXConcat(C identity)
```
    To manage javac type inference first assign the monoid
```
 
    
    Monoid<ListX<Integer>> listX = Monoid.of(identity,Semigroups.collectionXConcat(ListX.empty());
    Monoid<SetX<Integer>> setX = Monoid.of(identity,Semigroups.collectionXConcat(SetX.empty());
    
    
 
 
 
```
    Returns:
    
    A Monoid that can combine any cyclops2-react extended Collection type
  - mutableCollectionConcat
```
static <T,C extends java.util.Collection<T>> Monoid<C> mutableCollectionConcat(C identity)
```
    Concatenate mutable collections To manage javac type inference first assign the Monoid
```
 
    
    Monoid<List<Integer>> list =  Monoid.of(identity,Semigroups.collectionConcat(Arrays.asList());
    Monoid<Set<Integer>> set =  Monoid.of(identity,Semigroups.collectionConcat(new HashSet());
    
    
 
 
 
```
    Returns:
    
    A Monoid that can combine any mutable collection type
  - mutableListConcat
```
static <T> Monoid<java.util.List<T>> mutableListConcat()
```
    Returns:
    
    A combiner for mutable lists
  - mutableSetConcat
```
static <T> Monoid<java.util.Set<T>> mutableSetConcat()
```
    Returns:
    
    A combiner for mutable sets
  - mutableSortedSetConcat
```
static <T> Monoid<java.util.SortedSet<T>> mutableSortedSetConcat()
```
    Returns:
    
    A combiner for mutable SortedSets
  - mutableQueueConcat
```
static <T> Monoid<java.util.Queue<T>> mutableQueueConcat()
```
    Returns:
    
    A combiner for mutable Queues
  - mutableDequeConcat
```
static <T> Monoid<java.util.Deque<T>> mutableDequeConcat()
```
    Returns:
    
    A combiner for mutable Deques
  - listXConcat
```
static <T> Monoid<ListX<T>> listXConcat()
```
    Returns:
    
    A combiner for ListX (concatenates two ListX into a single ListX)
  - setXConcat
```
static <T> Monoid<SetX<T>> setXConcat()
```
    Returns:
    
    A combiner for SetX (concatenates two SetX into a single SetX)
  - sortedSetXConcat
```
static <T> Monoid<SortedSetX<T>> sortedSetXConcat()
```
    Returns:
    
    A combiner for SortedSetX (concatenates two SortedSetX into a single SortedSetX)
  - queueXConcat
```
static <T> Monoid<QueueX<T>> queueXConcat()
```
    Returns:
    
    A combiner for QueueX (concatenates two QueueX into a single QueueX)
  - dequeXConcat
```
static <T> Monoid<DequeX<T>> dequeXConcat()
```
    Returns:
    
    A combiner for DequeX (concatenates two DequeX into a single DequeX)
  - linkedListXConcat
```
static <T> Monoid<LinkedListX<T>> linkedListXConcat()
```
    Returns:
    
    A combiner for LinkedListX (concatenates two LinkedListX into a single LinkedListX)
  - vectorXConcat
```
static <T> Monoid<VectorX<T>> vectorXConcat()
```
    Returns:
    
    A combiner for VectorX (concatenates two VectorX into a single VectorX)
  - persistentSetXConcat
```
static <T> Monoid<PersistentSetX<T>> persistentSetXConcat()
```
    Returns:
    
    A combiner for PersistentSetX (concatenates two PersistentSetX into a single PersistentSetX)
  - orderedSetXConcat
```
static <T> Monoid<OrderedSetX<T>> orderedSetXConcat()
```
    Returns:
    
    A combiner for OrderedSetX (concatenates two OrderedSetX into a single OrderedSetX)
  - persistentQueueXConcat
```
static <T> Monoid<PersistentQueueX<T>> persistentQueueXConcat()
```
    Returns:
    
    A combiner for PersistentQueueX (concatenates two PersistentQueueX into a single PersistentQueueX)
  - bagXConcat
```
static <T> Monoid<BagX<T>> bagXConcat()
```
    Returns:
    
    A combiner for BagX (concatenates two BagX into a single BagX)
  - collectionConcat
```
static <T,C extends java.util.Collection<T>> Monoid<C> collectionConcat(C zero)
```
    This Semigroup will attempt toNested combine JDK Collections. If the Supplied are instances of cyclops2-react extended Collections or a pCollection persisent collection a new Collection type is created that contains the entries from both supplied collections. If the supplied Collections are standard JDK mutable collections Colleciton b is appended toNested Collection a and a is returned. To manage javac type inference first assign the semigroup
```
 
    
    Monoid<List<Integer>> list = Monoids.collectionConcat();
    Monoid<Set<Integer>> set = Monoids.collectionConcat();
    
    
 
 
 
```
    Returns:
    
    A Semigroup that attempts toNested combine the supplied Collections
  - combineScalarFunctors
```
static <T,A extends Zippable<T>> Monoid<A> combineScalarFunctors(java.util.function.Function<T,A> zeroFn,
                                                                 Monoid<T> monoid)
```
    Example sum integer Maybes
```
  
     Monoid<Maybe<Integer>> sumMaybes = Monoids.combineScalarFunctors(Maybe::just,Monoids.intSum);
 
 
```
    Parameters:
    
    zeroFn - Function toNested lift the Identity value into a Scalar Functor
    
    monoid - Monoid toNested combine the values inside the Scalar Functors
    
    Returns:
    
    Combination of two Scalar Functors
  - combineZippables
```
static <T,A extends Zippable<T>> Monoid<A> combineZippables(java.util.function.Function<T,A> zeroFn,
                                                            Monoid<T> monoid)
```
    Example sum integer Lists
```
  
      Monoid<ListX<Integer>> sumLists = Monoids.combineZippables(ListX::of,Monoids.intSum);
 
 
```
    Parameters:
    
    zeroFn - Function toNested lift the Identity value into a Zippable
    
    monoid - Monoid toNested combine the values inside the Zippables
    
    Returns:
    
    Combination of two Applicatives
  - combineFutureStream
```
static <T> Semigroup<FutureStream<T>> combineFutureStream()
```
    Returns:
    
    Combination of two LazyFutureStreams Streams b is appended toNested a
  - combineReactiveSeq
```
static <T> Monoid<ReactiveSeq<T>> combineReactiveSeq()
```
    Returns:
    
    Combination of two ReactiveSeq Streams b is appended toNested a
  - firstNonEmptyReactiveSeq
```
static <T> Monoid<ReactiveSeq<T>> firstNonEmptyReactiveSeq()
```
  - mergeLatestReactiveSeq
```
static <T> Monoid<ReactiveSeq<T>> mergeLatestReactiveSeq()
```
  - mergeLatest
```
static <T> Monoid<org.reactivestreams.Publisher<T>> mergeLatest()
```
  - amb
```
static <T> Monoid<org.reactivestreams.Publisher<T>> amb()
```
  - ambReactiveSeq
```
static <T> Monoid<ReactiveSeq<T>> ambReactiveSeq()
```
  - combineSeq
```
static <T> Monoid<org.jooq.lambda.Seq<T>> combineSeq()
```
    Returns:
    
    Combination of two Seq's : b is appended toNested a
  - combineStream
```
static <T> Monoid<java.util.stream.Stream<T>> combineStream()
```
    Returns:
    
    Combination of two Stream's : b is appended toNested a
  - firstNonEmpty
```
static <T,C extends java.util.Collection<T>> Monoid<C> firstNonEmpty(C zero)
```
    Parameters:
    
    zero - Empty Collection of same type
    
    Returns:
    
    Combination of two Collection, first non-empty is returned
  - lastNonEmpty
```
static <T,C extends java.util.Collection<T>> Monoid<C> lastNonEmpty(C zero)
```
    Parameters:
    
    zero - Empty Collection of same type
    
    Returns:
    
    Combination of two Collection, last non-empty is returned
  - firstNonNull
```
static <T> Monoid<T> firstNonNull()
```
    Returns:
    
    Combination of two Objects of same type, first non-null is returned
  - firstCompleteCompletableFuture
```
static <T> Monoid<java.util.concurrent.CompletableFuture<T>> firstCompleteCompletableFuture()
```
    Returns:
    
    Combine two CompletableFuture's by taking the first present
  - firstCompleteFuture
```
static <T> Monoid<Future<T>> firstCompleteFuture()
```
    Returns:
    
    Combine two Future's by taking the first result
  - firstOfSimpleReact
```
static <T> Monoid<SimpleReactStream<T>> firstOfSimpleReact()
```
  - firstSuccessfulFuture
```
static <T> Monoid<Future<T>> firstSuccessfulFuture()
```
    Returns:
    
    Combine two Future's by taking the first successful
  - firstPrimaryXor
```
static <ST,PT> Monoid<Xor<ST,PT>> firstPrimaryXor(ST zero)
```
    Returns:
    
    Combine two Xor's by taking the first primary
  - firstSecondaryXor
```
static <ST,PT> Monoid<Xor<ST,PT>> firstSecondaryXor(PT zero)
```
    Returns:
    
    Combine two Xor's by taking the first secondary
  - lastPrimaryXor
```
static <ST,PT> Monoid<Xor<ST,PT>> lastPrimaryXor(ST zero)
```
    Returns:
    
    Combine two Xor's by taking the last primary
  - lastSecondaryXor
```
static <ST,PT> Monoid<Xor<ST,PT>> lastSecondaryXor(PT zero)
```
    Returns:
    
    Combine two Xor's by taking the last secondary
  - firstTrySuccess
```
static <T,X extends java.lang.Throwable> Monoid<Try<T,X>> firstTrySuccess(X zero)
```
    Returns:
    
    Combine two Try's by taking the first primary
  - firstTryFailure
```
static <T,X extends java.lang.Throwable> Monoid<Try<T,X>> firstTryFailure(T zero)
```
    Returns:
    
    Combine two Try's by taking the first secondary
  - lastTrySuccess
```
static <T,X extends java.lang.Throwable> Monoid<Try<T,X>> lastTrySuccess(X zero)
```
    Returns:
    
    Combine two Tryr's by taking the last primary
  - lastTryFailure
```
static <T,X extends java.lang.Throwable> Monoid<Try<T,X>> lastTryFailure(T zero)
```
    Returns:
    
    Combine two Try's by taking the last secondary
  - firstPrimaryIor
```
static <ST,PT> Monoid<Ior<ST,PT>> firstPrimaryIor(ST zero)
```
    Returns:
    
    Combine two Ior's by taking the first primary
  - firstSecondaryIor
```
static <ST,PT> Monoid<Ior<ST,PT>> firstSecondaryIor(PT zero)
```
    Returns:
    
    Combine two Ior's by taking the first secondary
  - lastPrimaryIor
```
static <ST,PT> Monoid<Ior<ST,PT>> lastPrimaryIor(ST zero)
```
    Returns:
    
    Combine two Ior's by taking the last primary
  - lastSecondaryIor
```
static <ST,PT> Monoid<Ior<ST,PT>> lastSecondaryIor(PT zero)
```
    Returns:
    
    Combine two Ior's by taking the last secondary
  - firstPresentMaybe
```
static <T> Monoid<Maybe<T>> firstPresentMaybe()
```
    Returns:
    
    Combine two Maybe's by taking the first present
  - firstPresentOptional
```
static <T> Monoid<java.util.Optional<T>> firstPresentOptional()
```
    Returns:
    
    Combine two optionals by taking the first present
  - lastPresentMaybe
```
static <T> Monoid<Maybe<T>> lastPresentMaybe()
```
    Returns:
    
    Combine two Maybes by taking the last present
  - lastPresentOptional
```
static <T> Monoid<java.util.Optional<T>> lastPresentOptional()
```
    Returns:
    
    Combine two optionals by taking the last present
  - stringJoin
```
static Monoid<java.lang.String> stringJoin(java.lang.String joiner)
```
    Parameters:
    
    joiner - Separator in joined String
    
    Returns:
    
    Combine two strings separated by the supplied joiner
  - stringBuilderJoin
```
static Monoid<java.lang.StringBuilder> stringBuilderJoin(java.lang.String joiner)
```
    Parameters:
    
    joiner - Separator in joined String
    
    Returns:
    
    Combine two StringBuilders separated by the supplied joiner
  - stringBufferJoin
```
static Monoid<java.lang.StringBuffer> stringBufferJoin(java.lang.String joiner)
```
    Parameters:
    
    joiner - Separator in joined String
    
    Returns:
    
    Combine two StringBuffers separated by the supplied joiner
  - minComparable
```
static <T,T2 extends java.lang.Comparable<T>> Monoid<T2> minComparable(T2 max)
```
    Returns:
    
    Combine two Comparables taking the lowest each time
  - maxComparable
```
static <T,T2 extends java.lang.Comparable<T>> Monoid<T2> maxComparable(T2 min)
```
    Returns:
    
    Combine two Comparables taking the highest each time
  - functionComposition
```
static <A> Monoid<java.util.function.Function<A,A>> functionComposition()
```
    Returns:
    
    Monoid for composing function

Interface Monoids

Field Summary

Method Summary

Field Detail

bigIntCount

intCount

longCount

doubleCount

intSum

longSum

doubleSum

bigIntSum

intMult

longMult

doubleMult

bigIntMult

intMax

longMax

doubleMax

bigIntMax

intMin

longMin

doubleMin

bigIntMin

stringConcat

stringBufferConcat

stringBuilderConcat

booleanDisjunction

booleanXDisjunction

booleanConjunction

Method Detail

collectionXConcat

mutableCollectionConcat

mutableListConcat

mutableSetConcat

mutableSortedSetConcat

mutableQueueConcat

mutableDequeConcat

listXConcat

setXConcat

sortedSetXConcat

queueXConcat

dequeXConcat

linkedListXConcat

vectorXConcat

persistentSetXConcat

orderedSetXConcat

persistentQueueXConcat

bagXConcat

collectionConcat

combineScalarFunctors

combineZippables

combineFutureStream

combineReactiveSeq

firstNonEmptyReactiveSeq

mergeLatestReactiveSeq

mergeLatest

amb

ambReactiveSeq

combineSeq

combineStream

firstNonEmpty

lastNonEmpty

firstNonNull

firstCompleteCompletableFuture

firstCompleteFuture

firstOfSimpleReact

firstSuccessfulFuture

firstPrimaryXor

firstSecondaryXor

lastPrimaryXor

lastSecondaryXor

firstTrySuccess

firstTryFailure

lastTrySuccess

lastTryFailure

firstPrimaryIor

firstSecondaryIor

lastPrimaryIor

lastSecondaryIor