Monoids (cyclops-react 1.0.4 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 to 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 to a (can be used to 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 to a (can be used to 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 to a (can be used to 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 to a (can be used to 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,C extends java.util.Collection<T>> Monoid<C>`	`collectionConcat(C zero)` This Semigroup will attempt to 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<LazyFutureStream<T>>`	`combineFutureStream()`
`static <T> Monoid<ReactiveSeq<T>>`	`combineReactiveSeq()`
`static <T,A extends Combiner<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<FutureW<T>>`	`firstCompleteFuture()`
`static <T,C extends java.util.Collection<T>> Monoid<C>`	`firstNonEmpty(C zero)`
`static <T> Monoid<T>`	`firstNonNull()`
`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<FutureW<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<ListX<T>>`	`listXConcat()`
`static <T,T2 extends java.lang.Comparable<T>> Monoid<T2>`	`maxComparable(T2 min)`
`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<PBagX<T>>`	`pBagXConcat()`
`static <T> Monoid<POrderedSetX<T>>`	`pOrderedSetXConcat()`
`static <T> Monoid<PQueueX<T>>`	`pQueueXConcat()`
`static <T> Monoid<PSetX<T>>`	`pSetXConcat()`
`static <T> Monoid<PStackX<T>>`	`pStackXConcat()`
`static <T> Monoid<PVectorX<T>>`	`pVectorXConcat()`
`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)`

- Field Detail
  - bigIntCount
```
static final Monoid<java.math.BigInteger> bigIntCount
```
    Combine two BigIntegers by adding one to a (can be used to count BigIntegers in a Collection or Stream)
  - intCount
```
static final Monoid<java.lang.Integer> intCount
```
    Combine two Integers by adding one to a (can be used to count Integers in a Collection or Stream)
  - longCount
```
static final Monoid<java.lang.Long> longCount
```
    Combine two Longs by adding one to a (can be used to count Integers in a Collection or Stream)
  - doubleCount
```
static final Monoid<java.lang.Double> doubleCount
```
    Combine two Double by adding one to a (can be used to 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 cyclops-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)
  - pStackXConcat
```
static <T> Monoid<PStackX<T>> pStackXConcat()
```
    Returns:
    
    A combiner for PStackX (concatenates two PStackX into a single PStackX)
  - pVectorXConcat
```
static <T> Monoid<PVectorX<T>> pVectorXConcat()
```
    Returns:
    
    A combiner for PVectorX (concatenates two PVectorX into a single PVectorX)
  - pSetXConcat
```
static <T> Monoid<PSetX<T>> pSetXConcat()
```
    Returns:
    
    A combiner for PSetX (concatenates two PSetX into a single PSetX)
  - pOrderedSetXConcat
```
static <T> Monoid<POrderedSetX<T>> pOrderedSetXConcat()
```
    Returns:
    
    A combiner for POrderedSetX (concatenates two POrderedSetX into a single POrderedSetX)
  - pQueueXConcat
```
static <T> Monoid<PQueueX<T>> pQueueXConcat()
```
    Returns:
    
    A combiner for PQueueX (concatenates two PQueueX into a single PQueueX)
  - pBagXConcat
```
static <T> Monoid<PBagX<T>> pBagXConcat()
```
    Returns:
    
    A combiner for PBagX (concatenates two PBagX into a single PBagX)
  - collectionConcat
```
static <T,C extends java.util.Collection<T>> Monoid<C> collectionConcat(C zero)
```
    This Semigroup will attempt to combine JDK Collections. If the Supplied are instances of cyclops-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 to 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 to combine the supplied Collections
  - combineScalarFunctors
```
static <T,A extends Combiner<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 to lift the Identity value into a Scalar Functor
    
    monoid - Monoid to 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 to lift the Identity value into a Zippable
    
    monoid - Monoid to combine the values inside the Zippables
    
    Returns:
    
    Combination of two Applicatives
  - combineFutureStream
```
static <T> Semigroup<LazyFutureStream<T>> combineFutureStream()
```
    Returns:
    
    Combination of two LazyFutureStreams Streams b is appended to a
  - combineReactiveSeq
```
static <T> Monoid<ReactiveSeq<T>> combineReactiveSeq()
```
    Returns:
    
    Combination of two ReactiveSeq Streams b is appended to a
  - combineSeq
```
static <T> Monoid<org.jooq.lambda.Seq<T>> combineSeq()
```
    Returns:
    
    Combination of two Seq's : b is appended to a
  - combineStream
```
static <T> Monoid<java.util.stream.Stream<T>> combineStream()
```
    Returns:
    
    Combination of two Stream's : b is appended to 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<FutureW<T>> firstCompleteFuture()
```
    Returns:
    
    Combine two FutureW's by taking the first result
  - firstSuccessfulFuture
```
static <T> Monoid<FutureW<T>> firstSuccessfulFuture()
```
    Returns:
    
    Combine two FutureW'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 functions

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

pStackXConcat

pVectorXConcat

pSetXConcat

pOrderedSetXConcat

pQueueXConcat

pBagXConcat

collectionConcat

combineScalarFunctors

combineZippables

combineFutureStream

combineReactiveSeq

combineSeq

combineStream

firstNonEmpty

lastNonEmpty

firstNonNull

firstCompleteCompletableFuture

firstCompleteFuture

firstSuccessfulFuture

firstPrimaryXor

firstSecondaryXor

lastPrimaryXor

lastSecondaryXor

firstTrySuccess

firstTryFailure

lastTrySuccess

lastTryFailure

firstPrimaryIor

firstSecondaryIor

lastPrimaryIor

lastSecondaryIor

firstPresentMaybe

firstPresentOptional

lastPresentMaybe

lastPresentOptional

stringJoin

stringBuilderJoin