Semigroups (cyclops-react 2.0.0-MI7 API)

```
public interface Semigroups
```
A static class with a large number of Semigroups or Combiners. A semigroup is an Object that can be used toNested combine objects of the same type.

Field Summary

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

Method Summary

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

- Field Detail
  - bigIntCount
```
static final Semigroup<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 Semigroup<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 Semigroup<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 Semigroup<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 Semigroup<java.lang.Integer> intSum
```
    Combine two Integers by summing them
  - longSum
```
static final Semigroup<java.lang.Long> longSum
```
    Combine two Longs by summing them
  - doubleSum
```
static final Semigroup<java.lang.Double> doubleSum
```
    Combine two Doubles by summing them
  - bigIntSum
```
static final Semigroup<java.math.BigInteger> bigIntSum
```
    Combine two BigIngegers by summing them
  - intMult
```
static final Semigroup<java.lang.Integer> intMult
```
    Combine two Integers by multiplying them
  - longMult
```
static final Semigroup<java.lang.Long> longMult
```
    Combine two Longs by multiplying them
  - doubleMult
```
static final Semigroup<java.lang.Double> doubleMult
```
    Combine two Doubles by multiplying them
  - bigIntMult
```
static final Semigroup<java.math.BigInteger> bigIntMult
```
    Combine two BigIntegers by multiplying them
  - intMax
```
static final Semigroup<java.lang.Integer> intMax
```
    Combine two Integers by selecting the max
  - longMax
```
static final Semigroup<java.lang.Long> longMax
```
    Combine two Longs by selecting the max
  - doubleMax
```
static final Semigroup<java.lang.Double> doubleMax
```
    Combine two Doubles by selecting the max
  - bigIntMax
```
static final Semigroup<java.math.BigInteger> bigIntMax
```
    Combine two BigIntegers by selecting the max
  - intMin
```
static final Semigroup<java.lang.Integer> intMin
```
    Combine two Integers by selecting the min
  - longMin
```
static final Semigroup<java.lang.Long> longMin
```
    Combine two Longs by selecting the min
  - doubleMin
```
static final Semigroup<java.lang.Double> doubleMin
```
    Combine two Doubles by selecting the min
  - bigIntMin
```
static final Semigroup<java.math.BigInteger> bigIntMin
```
    Combine two BigIntegers by selecting the min
  - stringConcat
```
static final Semigroup<java.lang.String> stringConcat
```
    String concatenation
  - stringBufferConcat
```
static final Semigroup<java.lang.StringBuffer> stringBufferConcat
```
    StringBuffer concatenation
  - stringBuilderConcat
```
static final Semigroup<java.lang.StringBuilder> stringBuilderConcat
```
    StringBuilder concatenation
  - booleanDisjunction
```
static final Semigroup<java.lang.Boolean> booleanDisjunction
```
    Combine two booleans by OR'ing them (disjunction)
  - booleanXDisjunction
```
static final Semigroup<java.lang.Boolean> booleanXDisjunction
```
    Combine two booleans by XOR'ing them (exclusive disjunction)
  - booleanConjunction
```
static final Semigroup<java.lang.Boolean> booleanConjunction
```
    Combine two booleans by AND'ing them (conjunction)
- Method Detail
  - collectionXConcat
```
static <T,C extends FluentCollectionX<T>> Semigroup<C> collectionXConcat()
```
    To manage javac type inference first assign the semigroup
```
 
    
    Semigroup<ListX<Integer>> listX = Semigroups.collectionXConcat();
    Semigroup<SetX<Integer>> setX = Semigroups.collectionXConcat();
    
    
 
 
 
```
    Returns:
    
    A Semigroup that can combine any cyclops2-react extended Collection type
  - mutableCollectionConcat
```
static <T,C extends java.util.Collection<T>> Semigroup<C> mutableCollectionConcat()
```
    Concatenate mutable collections To manage javac type inference first assign the semigroup
```
 
    
    Semigroup<List<Integer>> list = Semigroups.collectionConcat();
    Semigroup<Set<Integer>> set = Semigroups.collectionConcat();
    
    
 
 
 
```
    Returns:
    
    A Semigroup that can combine any mutable collection type
  - mutableListConcat
```
static <T> Semigroup<java.util.List<T>> mutableListConcat()
```
    Returns:
    
    A combiner for mutable lists
  - mutableSetConcat
```
static <T> Semigroup<java.util.Set<T>> mutableSetConcat()
```
    Returns:
    
    A combiner for mutable sets
  - mutableSortedSetConcat
```
static <T> Semigroup<java.util.SortedSet<T>> mutableSortedSetConcat()
```
    Returns:
    
    A combiner for mutable SortedSets
  - mutableQueueConcat
```
static <T> Semigroup<java.util.Queue<T>> mutableQueueConcat()
```
    Returns:
    
    A combiner for mutable Queues
  - mutableDequeConcat
```
static <T> Semigroup<java.util.Deque<T>> mutableDequeConcat()
```
    Returns:
    
    A combiner for mutable Deques
  - listXConcat
```
static <T> Semigroup<ListX<T>> listXConcat()
```
    Returns:
    
    A combiner for ListX (concatenates two ListX into a single ListX)
  - setXConcat
```
static <T> Semigroup<SetX<T>> setXConcat()
```
    Returns:
    
    A combiner for SetX (concatenates two SetX into a single SetX)
  - sortedSetXConcat
```
static <T> Semigroup<SortedSetX<T>> sortedSetXConcat()
```
    Returns:
    
    A combiner for SortedSetX (concatenates two SortedSetX into a single SortedSetX)
  - queueXConcat
```
static <T> Semigroup<QueueX<T>> queueXConcat()
```
    Returns:
    
    A combiner for QueueX (concatenates two QueueX into a single QueueX)
  - dequeXConcat
```
static <T> Semigroup<DequeX<T>> dequeXConcat()
```
    Returns:
    
    A combiner for DequeX (concatenates two DequeX into a single DequeX)
  - linkedListXConcat
```
static <T> Semigroup<LinkedListX<T>> linkedListXConcat()
```
    Returns:
    
    A combiner for LinkedListX (concatenates two LinkedListX into a single LinkedListX)
  - vectorXConcat
```
static <T> Semigroup<VectorX<T>> vectorXConcat()
```
    Returns:
    
    A combiner for VectorX (concatenates two VectorX into a single VectorX)
  - persistentSetXConcat
```
static <T> Semigroup<PersistentSetX<T>> persistentSetXConcat()
```
    Returns:
    
    A combiner for PersistentSetX (concatenates two PersistentSetX into a single PersistentSetX)
  - orderedSetXConcat
```
static <T> Semigroup<OrderedSetX<T>> orderedSetXConcat()
```
    Returns:
    
    A combiner for OrderedSetX (concatenates two OrderedSetX into a single OrderedSetX)
  - persistentQueueXConcat
```
static <T> Semigroup<PersistentQueueX<T>> persistentQueueXConcat()
```
    Returns:
    
    A combiner for PersistentQueueX (concatenates two PersistentQueueX into a single PersistentQueueX)
  - bagXConcat
```
static <T> Semigroup<BagX<T>> bagXConcat()
```
    Returns:
    
    A combiner for BagX (concatenates two BagX into a single BagX)
  - collectionConcat
```
static <T,C extends java.util.Collection<T>> Semigroup<C> collectionConcat()
```
    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
```
 
    
    Semigroup<List<Integer>> list = Semigroups.collectionConcat();
    Semigroup<Set<Integer>> set = Semigroups.collectionConcat();
    
    
 
 
 
```
    Returns:
    
    A Semigroup that attempts toNested combine the supplied Collections
  - combineZippables
```
static <T,A extends Zippable<T>> Semigroup<A> combineZippables(java.util.function.BiFunction<T,T,T> semigroup)
```
```
  
  BinaryOperator<Zippable<Integer>> sumInts = Semigroups.combineZippables(Semigroups.intSum);
        sumInts.apply(ListX.of(1,2,3), ListX.of(4,5,6));
        
        //List[5,7,9];
 
 
 
```
    Parameters:
    
    semigroup - Semigroup toNested combine the values inside the zippables
    
    Returns:
    
    Combination of two Zippables
  - combineScalarFunctors
```
static <T,A extends Zippable<T>> Semigroup<A> combineScalarFunctors(java.util.function.BiFunction<T,T,T> semigroup)
```
```
  
 
  BinaryOperator<Combiner<Integer>> sumMaybes = Semigroups.combineScalarFunctors(Semigroups.intSum);
  Maybe.just(1)
       .combine(sumMaybes, Maybe.just(5))
       
  //Maybe[6]     
 
 
```
    Parameters:
    
    semigroup - Semigroup toNested combine the values inside the Scalar Functors (Maybe, Xor, Ior, Try, Eva, FeatureToggle etc)
    
    Returns:
    
    Combination of two Scalar Functors
  - combineFutureStream
```
static <T> Semigroup<FutureStream<T>> combineFutureStream()
```
    Returns:
    
    Combination of two LazyFutureStreams Streams b is appended toNested a
  - combineReactiveSeq
```
static <T> Semigroup<ReactiveSeq<T>> combineReactiveSeq()
```
    Returns:
    
    Combination of two ReactiveSeq Streams b is appended toNested a
  - firstNonEmptyReactiveSeq
```
static <T> Semigroup<ReactiveSeq<T>> firstNonEmptyReactiveSeq()
```
  - ambReactiveSeq
```
static <T> Semigroup<ReactiveSeq<T>> ambReactiveSeq()
```
  - mergeLatestReactiveSeq
```
static <T> Semigroup<ReactiveSeq<T>> mergeLatestReactiveSeq()
```
  - mergeLatest
```
static <T> Semigroup<org.reactivestreams.Publisher<T>> mergeLatest()
```
  - amb
```
static <T> Semigroup<org.reactivestreams.Publisher<T>> amb()
```
  - combineSeq
```
static <T> Semigroup<org.jooq.lambda.Seq<T>> combineSeq()
```
    Returns:
    
    Combination of two Seq's : b is appended toNested a
  - combineStream
```
static <T> Semigroup<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>> Semigroup<C> firstNonEmpty()
```
    Returns:
    
    Combination of two Collection, first non-empty is returned
  - lastNonEmpty
```
static <T,C extends java.util.Collection<T>> Semigroup<C> lastNonEmpty()
```
    Returns:
    
    Combination of two Collection, last non-empty is returned
  - firstNonNull
```
static <T> Semigroup<T> firstNonNull()
```
    Returns:
    
    Combination of two Objects of same type, first non-null is returned
  - firstCompleteCompletableFuture
```
static <T> Semigroup<java.util.concurrent.CompletableFuture<T>> firstCompleteCompletableFuture()
```
    Returns:
    
    Combine two CompletableFuture's by taking the first present
  - firstCompleteFuture
```
static <T> Semigroup<Future<T>> firstCompleteFuture()
```
    Returns:
    
    Combine two Future's by taking the first result
  - firstOfSimpleReact
```
static <T> Semigroup<SimpleReactStream<T>> firstOfSimpleReact()
```
  - firstSuccessfulFuture
```
static <T> Semigroup<Future<T>> firstSuccessfulFuture()
```
    Returns:
    
    Combine two Future's by taking the first successful
  - firstPrimaryXor
```
static <ST,PT> Semigroup<Xor<ST,PT>> firstPrimaryXor()
```
    Returns:
    
    Combine two Xor's by taking the first primary
  - firstSecondaryXor
```
static <ST,PT> Semigroup<Xor<ST,PT>> firstSecondaryXor()
```
    Returns:
    
    Combine two Xor's by taking the first secondary
  - lastPrimaryXor
```
static <ST,PT> Semigroup<Xor<ST,PT>> lastPrimaryXor()
```
    Returns:
    
    Combine two Xor's by taking the last primary
  - lastSecondaryXor
```
static <ST,PT> Semigroup<Xor<ST,PT>> lastSecondaryXor()
```
    Returns:
    
    Combine two Xor's by taking the last secondary
  - firstTrySuccess
```
static <T,X extends java.lang.Throwable> Semigroup<Try<T,X>> firstTrySuccess()
```
    Returns:
    
    Combine two Try's by taking the first primary
  - firstTryFailure
```
static <T,X extends java.lang.Throwable> Semigroup<Try<T,X>> firstTryFailure()
```
    Returns:
    
    Combine two Try's by taking the first secondary
  - lastTrySuccess
```
static <T,X extends java.lang.Throwable> Semigroup<Try<T,X>> lastTrySuccess()
```
    Returns:
    
    Combine two Tryr's by taking the last primary
  - lastTryFailure
```
static <T,X extends java.lang.Throwable> Semigroup<Try<T,X>> lastTryFailure()
```
    Returns:
    
    Combine two Try's by taking the last secondary
  - firstPrimaryIor
```
static <ST,PT> Semigroup<Ior<ST,PT>> firstPrimaryIor()
```
    Returns:
    
    Combine two Ior's by taking the first primary
  - firstSecondaryIor
```
static <ST,PT> Semigroup<Ior<ST,PT>> firstSecondaryIor()
```
    Returns:
    
    Combine two Ior's by taking the first secondary
  - lastPrimaryIor
```
static <ST,PT> Semigroup<Ior<ST,PT>> lastPrimaryIor()
```
    Returns:
    
    Combine two Ior's by taking the last primary
  - lastSecondaryIor
```
static <ST,PT> Semigroup<Ior<ST,PT>> lastSecondaryIor()
```
    Returns:
    
    Combine two Ior's by taking the last secondary
  - firstPresentMaybe
```
static <T> Semigroup<Maybe<T>> firstPresentMaybe()
```
    Returns:
    
    Combine two Maybe's by taking the first present
  - firstPresentOptional
```
static <T> Semigroup<java.util.Optional<T>> firstPresentOptional()
```
    Returns:
    
    Combine two optionals by taking the first present
  - lastPresentMaybe
```
static <T> Semigroup<Maybe<T>> lastPresentMaybe()
```
    Returns:
    
    Combine two Maybes by taking the last present
  - lastPresentOptional
```
static <T> Semigroup<java.util.Optional<T>> lastPresentOptional()
```
    Returns:
    
    Combine two optionals by taking the last present
  - stringJoin
```
static Semigroup<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 Semigroup<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 Semigroup<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>> Semigroup<T2> minComparable()
```
    Returns:
    
    Combine two Comparables taking the lowest each time
  - maxComparable
```
static <T,T2 extends java.lang.Comparable<T>> Semigroup<T2> maxComparable()
```
    Returns:
    
    Combine two Comparables taking the highest each time
  - functionComposition
```
static <A> Semigroup<java.util.function.Function<A,A>> functionComposition()
```
    Returns:
    
    Combine function

Interface Semigroups

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

combineZippables

combineScalarFunctors

combineFutureStream

combineReactiveSeq

firstNonEmptyReactiveSeq

ambReactiveSeq

mergeLatestReactiveSeq

mergeLatest

amb

combineSeq

combineStream

firstNonEmpty

lastNonEmpty

firstNonNull

firstCompleteCompletableFuture

firstCompleteFuture

firstOfSimpleReact

firstSuccessfulFuture

firstPrimaryXor

firstSecondaryXor

lastPrimaryXor

lastSecondaryXor

firstTrySuccess

firstTryFailure

lastTrySuccess

lastTryFailure

firstPrimaryIor

firstSecondaryIor

lastPrimaryIor

lastSecondaryIor