XorT (cyclops-reactor 9.0.0-FINAL API)

java.lang.Object
- com.aol.cyclops2.types.anyM.transformers.ValueTransformer<W,T>
- - cyclops.monads.transformers.XorT<W,ST,T>

Type Parameters:

T - Type of data stored inside the nested Maybe(s)

All Implemented Interfaces:

Unit<T>, Filters<T>, Folds<T>, To<XorT<W,ST,T>>, Transformable<T>, Unwrapable, Zippable<T>, Fn0<T>, java.lang.Iterable<T>, java.util.function.Supplier<T>, org.reactivestreams.Publisher<T>
```
public final class XorT<W extends WitnessType<W>,ST,T>
extends ValueTransformer<W,T>
implements To<XorT<W,ST,T>>, Transformable<T>, Filters<T>
```
Monad Transformer for Xor's MaybeT allows the deeply wrapped Maybe to be manipulating within it's nested /contained context

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.function.Fn0
  Fn0.FunctionalOperations<R>, Fn0.Instances, Fn0.SupplierKind<R>

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`<U> XorT<W,ST,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream to a given type, possibly throwing a `ClassCastException`.
`<T2,R> XorT<W,ST,R>`	`combine(Value<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)`
`<R> XorT<W,ST,R>`	`empty()`
`boolean`	`equals(java.lang.Object o)`
`XorT<W,ST,T>`	`filter(java.util.function.Predicate<? super T> test)` Keep only elements for which the supplied predicates hold e.g.
`XorT<W,ST,T>`	`filterNot(java.util.function.Predicate<? super T> predicate)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<B> XorT<W,ST,B>`	`flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends B>> f)`
`<R> XorT<W,ST,R>`	`flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)`
`<R> XorT<W,ST,R>`	`flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)`
`<B> XorT<W,ST,B>`	`flatMapT(java.util.function.Function<? super T,XorT<W,ST,B>> f)` Flat Map the wrapped Maybe
`<R1,R> XorT<W,ST,R>`	`forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<R1,R> XorT<W,ST,R>`	`forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<R1,R> XorT<W,ST,R>`	`forEach2M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<R1,R> XorT<W,ST,R>`	`forEach2M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<T2,R1,R2,R> XorT<W,ST,R>`	`forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<T2,R1,R2,R> XorT<W,ST,R>`	`forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<T2,R1,R2,R> XorT<W,ST,R>`	`forEach3M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends XorT<W,ST,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<T2,R1,R2,R> XorT<W,ST,R>`	`forEach3M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends XorT<W,ST,R2>> value2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<T2,R1,R2,R3,R> XorT<W,ST,R>`	`forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`<T2,R1,R2,R3,R> XorT<W,ST,R>`	`forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`<T2,R1,R2,R3,R> XorT<W,ST,R>`	`forEach4M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends XorT<W,ST,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends XorT<W,ST,R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`<T2,R1,R2,R3,R> XorT<W,ST,R>`	`forEach4M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends XorT<W,ST,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends XorT<W,ST,R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`static <W extends WitnessType<W>,ST,A> XorT<W,ST,A>`	`fromAnyM(AnyM<W,A> anyM)` Construct an MaybeWT from an AnyM that contains a monad type that contains type other than Maybe The values in the underlying monad will be mapped to Maybe
`AnyM<W,? extends ReactiveSeq<T>>`	`generate()`
`int`	`hashCode()`
`AnyM<W,? extends ReactiveSeq<T>>`	`iterate(java.util.function.UnaryOperator<T> fn)` public AnyM> reactiveStream() { return this.transformerStream().map(v->v.reactiveStream()); }
`java.util.Iterator<T>`	`iterator()`
`static <W extends WitnessType<W>,U,ST,R> java.util.function.Function<XorT<W,ST,U>,XorT<W,ST,R>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an MaybeWT This allows multiple monad types to add functionality to existing function and methods e.g.
`static <W extends WitnessType<W>,ST,U1,U2,R> java.util.function.BiFunction<XorT<W,ST,U1>,XorT<W,ST,U2>,XorT<W,ST,R>>`	`lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)` Lift a BiFunction into one that accepts and returns MaybeWTs This allows multiple monad types to add functionality to existing function and methods e.g.
`<B> XorT<W,ST,B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped Maybe
`java.lang.String`	`mkString()`
`XorT<W,ST,T>`	`notNull()` Filter elements retaining only values which are not null
`static <W extends WitnessType<W>,ST,A> XorT<W,ST,A>`	`of(AnyM<W,Xor<ST,A>> monads)` Construct an MaybeWT from an AnyM that wraps a monad containing MaybeWs
`<U> XorT<W,ST,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a reactiveStream that are of a given type.
`XorT<W,ST,T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the Maybe
`ReactiveSeq<T>`	`stream()`
`java.lang.String`	`toString()`
`<R> XorT<W,ST,R>`	`trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`AnyM<W,? extends MonadicValue<T>>`	`transformerStream()`
`<R> XorT<W,ST,R>`	`unit(R value)`
`protected <R> XorT<W,ST,R>`	`unitAnyM(AnyM<W,? super MonadicValue<R>> traversable)` Deprecated.
`<R> XorT<W,ST,R>`	`unitIterator(java.util.Iterator<R> it)`
`AnyM<W,Xor<ST,T>>`	`unwrap()` Unwrap a wrapped value
`<R> R`	`unwrapTo(java.util.function.Function<? super AnyM<W,Xor<ST,T>>,? extends R> fn)`
`XorT<W,ST,T>`	`zip(java.util.function.BinaryOperator<Zippable<T>> combiner, Zippable<T> app)` Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout SemigroupK and Monoids for a large number of canned combinations).
`<T2,R> XorT<W,ST,R>`	`zip(java.lang.Iterable<? extends T2> iterable, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`<U> XorT<W,ST,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)` Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
`<S,U> XorT<W,ST,org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)` zip 3 Streams into one
`<S,U,R> XorT<W,ST,R>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Fn3<? super T,? super S,? super U,? extends R> fn3)`
`<T2,T3,T4> XorT<W,ST,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)` zip 4 Streams into 1
`<T2,T3,T4,R> XorT<W,ST,R>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)`
`<T2,R> XorT<W,ST,R>`	`zipP(org.reactivestreams.Publisher<? extends T2> publisher, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`<U> XorT<W,ST,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`<U> XorT<W,ST,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipS(java.util.stream.Stream<? extends U> other)` Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
`<U,R> XorT<W,ST,R>`	`zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
`<R> XorT<W,ST,R>`	`zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)`
`<R> XorT<W,ST,R>`	`zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)`
`<R> XorT<W,ST,R>`	`zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)`

Methods inherited from class com.aol.cyclops2.types.anyM.transformers.ValueTransformer
and, get, isPresent, negate, or, orElse, orElseGet, orElseThrow, subscribe, visit, zip

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.aol.cyclops2.types.foldable.To
to

Methods inherited from interface com.aol.cyclops2.types.functor.Transformable
retry, retry

Methods inherited from interface com.aol.cyclops2.types.Unwrapable
unwrapIfInstance, unwrapNested

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleUnsafe, startsWith, startsWithIterable, takeOne, xMatch

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface cyclops.function.Fn0
andThen, apply, fnTo, functionOps, future, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, memoizeAsync, memoizeAsync, run, suspend, toEval, λ, λv

Method Detail

iterator
```
public java.util.Iterator<T> iterator()
```
Specified by:

iterator in interface java.lang.Iterable<T>

stream
```
public ReactiveSeq<T> stream()
```
Specified by:

stream in interface Folds<T>

unwrap
```
public AnyM<W,Xor<ST,T>> unwrap()
```
Description copied from interface: Unwrapable

Unwrap a wrapped value

Specified by:

unwrap in interface Unwrapable

Returns:

The wrapped AnyM

unwrapTo

public <R> R unwrapTo(java.util.function.Function<? super AnyM<W,Xor<ST,T>>,? extends R> fn)

unitAnyM

@Deprecated
protected <R> XorT<W,ST,R> unitAnyM(AnyM<W,? super MonadicValue<R>> traversable)

Deprecated.

Specified by:: unitAnyM in class ValueTransformer<W extends WitnessType<W>,T>

transformerStream
```
public AnyM<W,? extends MonadicValue<T>> transformerStream()
```
Specified by:

transformerStream in class ValueTransformer<W extends WitnessType<W>,T>

filter
```
public XorT<W,ST,T> filter(java.util.function.Predicate<? super T> test)
```
Description copied from interface: Filters
Keep only elements for which the supplied predicates hold e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[3]
   
 
 
```
Specified by:

filter in interface Filters<T>

Parameters:

test - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

peek

public XorT<W,ST,T> peek(java.util.function.Consumer<? super T> peek)

Peek at the current value of the Maybe

  
    MaybeWT.of(AnyM.fromStream(Arrays.asMaybeW(10))
             .peek(System.out::println);
             
     //prints 10

Specified by:: peek in interface Transformable<T>
Parameters:: peek - Consumer to accept current value of Maybe
Returns:: MaybeWT with peek call

map

public <B> XorT<W,ST,B> map(java.util.function.Function<? super T,? extends B> f)

Map the wrapped Maybe

  
  MaybeWT.of(AnyM.fromStream(Arrays.asMaybeW(10))
             .map(t->t=t+1);
  
  
  //MaybeWT<AnyMSeq<Stream<Maybe[11]>>>

Specified by:: map in interface Transformable<T>
Parameters:: f - Mapping function for the wrapped Maybe
Returns:: MaybeWT that applies the map function to the wrapped Maybe

flatMapT

public <B> XorT<W,ST,B> flatMapT(java.util.function.Function<? super T,XorT<W,ST,B>> f)

Flat Map the wrapped Maybe

  
  MaybeWT.of(AnyM.fromStream(Arrays.asMaybeW(10))
             .flatMap(t->Maybe.completedMaybe(20));
  
  
  //MaybeWT<AnyMSeq<Stream<Maybe[20]>>>

Parameters:: f - FlatMap function
Returns:: MaybeWT that applies the flatMap function to the wrapped Maybe

flatMap

public <B> XorT<W,ST,B> flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends B>> f)

Specified by:: flatMap in class ValueTransformer<W extends WitnessType<W>,T>

lift

public static <W extends WitnessType<W>,U,ST,R> java.util.function.Function<XorT<W,ST,U>,XorT<W,ST,R>> lift(java.util.function.Function<? super U,? extends R> fn)

Lift a function into one that accepts and returns an MaybeWT This allows multiple monad types to add functionality to existing function and methods e.g. to add list handling / iteration (via Maybe) and iteration (via Stream) to an existing function

  
        Function<Integer,Integer> add2 = i -> i+2;
    	Function<MaybeWT<Integer>, MaybeWT<Integer>> optTAdd2 = MaybeWT.lift(add2);
    	
    	Stream<Integer> withNulls = Stream.of(1,2,3);
    	AnyMSeq<Integer> reactiveStream = AnyM.fromStream(withNulls);
    	AnyMSeq<Maybe<Integer>> streamOpt = reactiveStream.map(Maybe::completedMaybe);
    	List<Integer> results = optTAdd2.applyHKT(MaybeWT.of(streamOpt))
    									.unwrap()
    									.<Stream<Maybe<Integer>>>unwrap()
    									.map(Maybe::join)
    									.collect(CyclopsCollectors.toList());
    	
    	
    	//Maybe.completedMaybe(List[3,4]);

Parameters:: fn - Function to enhance with functionality from Maybe and another monad type
Returns:: Function that accepts and returns an MaybeWT

lift2

public static <W extends WitnessType<W>,ST,U1,U2,R> java.util.function.BiFunction<XorT<W,ST,U1>,XorT<W,ST,U2>,XorT<W,ST,R>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)

Lift a BiFunction into one that accepts and returns MaybeWTs This allows multiple monad types to add functionality to existing function and methods e.g. to add list handling / iteration (via Maybe), iteration (via Stream) and asynchronous execution (Maybe) to an existing function

  
    	BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;
    	BiFunction<MaybeWT<Integer>,MaybeWT<Integer>,MaybeWT<Integer>> optTAdd2 = MaybeWT.lift2(add);
    	
    	Stream<Integer> withNulls = Stream.of(1,2,3);
    	AnyMSeq<Integer> reactiveStream = AnyM.ofMonad(withNulls);
    	AnyMSeq<Maybe<Integer>> streamOpt = reactiveStream.map(Maybe::completedMaybe);
    	
    	Maybe<Maybe<Integer>> two = Maybe.completedMaybe(Maybe.completedMaybe(2));
    	AnyMSeq<Maybe<Integer>> Maybe=  AnyM.fromMaybeW(two);
    	List<Integer> results = optTAdd2.applyHKT(MaybeWT.of(streamOpt),MaybeWT.of(Maybe))
    									.unwrap()
    									.<Stream<Maybe<Integer>>>unwrap()
    									.map(Maybe::join)
    									.collect(CyclopsCollectors.toList());
    									
    		//Maybe.completedMaybe(List[3,4,5]);

Parameters:: fn - BiFunction to enhance with functionality from Maybe and another monad type
Returns:: Function that accepts and returns an MaybeWT

fromAnyM
```
public static <W extends WitnessType<W>,ST,A> XorT<W,ST,A> fromAnyM(AnyM<W,A> anyM)
```
Construct an MaybeWT from an AnyM that contains a monad type that contains type other than Maybe The values in the underlying monad will be mapped to Maybe

Parameters:

anyM - AnyM that doesn't contain a monad wrapping an Maybe

Returns:

MaybeWT

of
```
public static <W extends WitnessType<W>,ST,A> XorT<W,ST,A> of(AnyM<W,Xor<ST,A>> monads)
```
Construct an MaybeWT from an AnyM that wraps a monad containing MaybeWs

Parameters:

monads - AnyM that contains a monad wrapping an Maybe

Returns:

MaybeWT

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

unitIterator

public <R> XorT<W,ST,R> unitIterator(java.util.Iterator<R> it)

unit

public <R> XorT<W,ST,R> unit(R value)

Specified by:: unit in interface Unit<T>

empty
```
public <R> XorT<W,ST,R> empty()
```
Specified by:

empty in class ValueTransformer<W extends WitnessType<W>,T>

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class java.lang.Object

equals
```
public boolean equals(java.lang.Object o)
```
Overrides:

equals in class java.lang.Object

combine

public <T2,R> XorT<W,ST,R> combine(Value<? extends T2> app,
                                   java.util.function.BiFunction<? super T,? super T2,? extends R> fn)

Overrides:: combine in class ValueTransformer<W extends WitnessType<W>,T>

zip
```
public XorT<W,ST,T> zip(java.util.function.BinaryOperator<Zippable<T>> combiner,
                        Zippable<T> app)
```
Description copied from interface: Zippable

Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout SemigroupK and Monoids for a large number of canned combinations). If this Applicative is a scalar value the provided value is combined with that value, otherwise the value is combined pair wise with all value in a non-scalar datastructure
Specified by:

zip in interface Zippable<T>

Overrides:

zip in class ValueTransformer<W extends WitnessType<W>,T>

Returns:

See Also:
Semigroup, Semigroups, Monoid,
To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in SemigroupK {@see com.aol.cyclops2.SemigroupK#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid) } {@code BinaryOperator> sumMaybes = SemigroupK.combineScalarFunctors(SemigroupK.intSum); Maybe.just(1).zip(sumMaybes, Maybe.just(5)) //Maybe.just(6)); }

iterate
```
public AnyM<W,? extends ReactiveSeq<T>> iterate(java.util.function.UnaryOperator<T> fn)
```
Description copied from class: ValueTransformer

public AnyM> reactiveStream() { return this.transformerStream().map(v->v.reactiveStream()); }

Overrides:

iterate in class ValueTransformer<W extends WitnessType<W>,T>

generate
```
public AnyM<W,? extends ReactiveSeq<T>> generate()
```
Overrides:

generate in class ValueTransformer<W extends WitnessType<W>,T>

zip
```
public <T2,R> XorT<W,ST,R> zip(java.lang.Iterable<? extends T2> iterable,
                               java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable using the supplied combining function

Specified by:

zip in interface Zippable<T>

Overrides:

zip in class ValueTransformer<W extends WitnessType<W>,T>

Parameters:

iterable - to zip with

fn - Zip function

Returns:

Combined zippable

zipP
```
public <T2,R> XorT<W,ST,R> zipP(org.reactivestreams.Publisher<? extends T2> publisher,
                                java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function

Specified by:

zipP in interface Zippable<T>

Overrides:

zipP in class ValueTransformer<W extends WitnessType<W>,T>

Parameters:

publisher - to combine with

fn - Zip / combining function

Returns:

Combined zippable

zipS
```
public <U> XorT<W,ST,org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
```
Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2

Specified by:

zipS in interface Zippable<T>

Overrides:

zipS in class ValueTransformer<W extends WitnessType<W>,T>

Parameters:

other - Stream to combine with

Returns:

Combined Zippable

zip
```
public <U> XorT<W,ST,org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2

Specified by:

zip in interface Zippable<T>

Overrides:

zip in class ValueTransformer<W extends WitnessType<W>,T>

Parameters:

other - Iterable to combine with

Returns:

forEach4

public <T2,R1,R2,R3,R> XorT<W,ST,R> forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                             java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                             Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                             Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Overrides:: forEach4 in class ValueTransformer<W extends WitnessType<W>,T>

forEach4

public <T2,R1,R2,R3,R> XorT<W,ST,R> forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                             java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                             Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                             Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                             Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Overrides:: forEach4 in class ValueTransformer<W extends WitnessType<W>,T>

forEach3

public <T2,R1,R2,R> XorT<W,ST,R> forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                          java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                          Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)

Overrides:: forEach3 in class ValueTransformer<W extends WitnessType<W>,T>

forEach3

public <T2,R1,R2,R> XorT<W,ST,R> forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                          java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                          Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                          Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)

Overrides:: forEach3 in class ValueTransformer<W extends WitnessType<W>,T>

forEach2

public <R1,R> XorT<W,ST,R> forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                    java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

Overrides:: forEach2 in class ValueTransformer<W extends WitnessType<W>,T>

forEach2

public <R1,R> XorT<W,ST,R> forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                    java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
                                    java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

Overrides:: forEach2 in class ValueTransformer<W extends WitnessType<W>,T>

flatMapIterable

public <R> XorT<W,ST,R> flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)

Overrides:: flatMapIterable in class ValueTransformer<W extends WitnessType<W>,T>

flatMapPublisher

public <R> XorT<W,ST,R> flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

Overrides:: flatMapPublisher in class ValueTransformer<W extends WitnessType<W>,T>

forEach4M

public <T2,R1,R2,R3,R> XorT<W,ST,R> forEach4M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1,
                                              java.util.function.BiFunction<? super T,? super R1,? extends XorT<W,ST,R2>> value2,
                                              Fn3<? super T,? super R1,? super R2,? extends XorT<W,ST,R3>> value3,
                                              Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

forEach4M

public <T2,R1,R2,R3,R> XorT<W,ST,R> forEach4M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1,
                                              java.util.function.BiFunction<? super T,? super R1,? extends XorT<W,ST,R2>> value2,
                                              Fn3<? super T,? super R1,? super R2,? extends XorT<W,ST,R3>> value3,
                                              Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                              Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

forEach3M

public <T2,R1,R2,R> XorT<W,ST,R> forEach3M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1,
                                           java.util.function.BiFunction<? super T,? super R1,? extends XorT<W,ST,R2>> value2,
                                           Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)

forEach3M

public <T2,R1,R2,R> XorT<W,ST,R> forEach3M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1,
                                           java.util.function.BiFunction<? super T,? super R1,? extends XorT<W,ST,R2>> value2,
                                           Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                           Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)

forEach2M

public <R1,R> XorT<W,ST,R> forEach2M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1,
                                     java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

forEach2M

public <R1,R> XorT<W,ST,R> forEach2M(java.util.function.Function<? super T,? extends XorT<W,ST,R1>> value1,
                                     java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
                                     java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

mkString
```
public java.lang.String mkString()
```

cast
```
public <U> XorT<W,ST,U> cast(java.lang.Class<? extends U> type)
```
Description copied from interface: Transformable

Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Transformable<T>

ofType

public <U> XorT<W,ST,U> ofType(java.lang.Class<? extends U> type)

Description copied from interface: Filters

Keep only those elements in a reactiveStream that are of a given type.

  
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)

Specified by:: ofType in interface Filters<T>

filterNot
```
public XorT<W,ST,T> filterNot(java.util.function.Predicate<? super T> predicate)
```
Description copied from interface: Filters
Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 
```
Specified by:

filterNot in interface Filters<T>

Parameters:

predicate - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

notNull
```
public XorT<W,ST,T> notNull()
```
Description copied from interface: Filters
Filter elements retaining only values which are not null
```
  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
 
```
Specified by:

notNull in interface Filters<T>

Returns:

Filters with nulls removed

zipWith

public <R> XorT<W,ST,R> zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)

Specified by:: zipWith in interface Zippable<T>

zipWithS

public <R> XorT<W,ST,R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)

Specified by:: zipWithS in interface Zippable<T>

zipWithP

public <R> XorT<W,ST,R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)

Specified by:: zipWithP in interface Zippable<T>

trampoline

public <R> XorT<W,ST,R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)

Description copied from interface: Transformable

Performs a map operation that can call a recursive method without running out of stack space

 
 ReactiveSeq.of(10,20,30,40)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);

    	Trampoline<Long> fibonacci(int i){
    		return fibonacci(i,1,0);
    	}
    	Trampoline<Long> fibonacci(int n, long a, long b) {
        	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
    	}

 55
    	6765
    	832040
    	102334155


 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);


 completes successfully

Specified by:: trampoline in interface Transformable<T>
Parameters:: mapper - TCO Transformation function
Returns:: Transformable transformed by the supplied transformation function

zipS
```
public <U,R> XorT<W,ST,R> zipS(java.util.stream.Stream<? extends U> other,
                               java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

Specified by:

zipS in interface Zippable<T>

Parameters:

other - Stream to combine with

zipper - Zip / combining function

Returns:

Combined zippable

zipP

public <U> XorT<W,ST,org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)

Specified by:: zipP in interface Zippable<T>

zip3

public <S,U> XorT<W,ST,org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
                                                                 java.lang.Iterable<? extends U> third)

Description copied from interface: Zippable

zip 3 Streams into one

 
  List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(CyclopsCollectors.toList());

  // [[1,100,'a'],[2,200,'b'],[3,300,'c']]

Specified by:: zip3 in interface Zippable<T>

zip3

public <S,U,R> XorT<W,ST,R> zip3(java.lang.Iterable<? extends S> second,
                                 java.lang.Iterable<? extends U> third,
                                 Fn3<? super T,? super S,? super U,? extends R> fn3)

Specified by:: zip3 in interface Zippable<T>

zip4

public <T2,T3,T4> XorT<W,ST,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
                                                                           java.lang.Iterable<? extends T3> third,
                                                                           java.lang.Iterable<? extends T4> fourth)

Description copied from interface: Zippable

zip 4 Streams into 1

 
  List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
          .collect(CyclopsCollectors.toList());

 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]

Specified by:: zip4 in interface Zippable<T>

zip4

public <T2,T3,T4,R> XorT<W,ST,R> zip4(java.lang.Iterable<? extends T2> second,
                                      java.lang.Iterable<? extends T3> third,
                                      java.lang.Iterable<? extends T4> fourth,
                                      Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)

Specified by:: zip4 in interface Zippable<T>

Class XorT<W extends WitnessType<W>,ST,T>

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.function.Fn0

Method Summary

Methods inherited from class com.aol.cyclops2.types.anyM.transformers.ValueTransformer

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops2.types.foldable.To

Methods inherited from interface com.aol.cyclops2.types.functor.Transformable

Methods inherited from interface com.aol.cyclops2.types.Unwrapable

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds

Methods inherited from interface java.lang.Iterable

Methods inherited from interface cyclops.function.Fn0

Method Detail

iterator

stream

unwrap

unwrapTo

unitAnyM

transformerStream

filter

peek

map

flatMapT

flatMap

lift

lift2

fromAnyM

of

toString

unitIterator

unit

empty

hashCode

equals

combine

zip

iterate

generate

zip

zipP

zipS

zip

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

flatMapIterable

flatMapPublisher

forEach4M

forEach4M

forEach3M

forEach3M

forEach2M

forEach2M

mkString

cast

ofType

filterNot

notNull

zipWith

zipWithS

zipWithP

trampoline

zipS

zipP

zip3

zip3

zip4

zip4