XorM (cyclops-react 2.1.1 API)

java.lang.Object
- cyclops.monads.XorM<W1,W2,T>

Type Parameters:: W1 - Witness type of monad; W2 - Witness type of monad; T - Data type

All Implemented Interfaces:: Filters<T>, Folds<T>, To<XorM<W1,W2,T>>, Transformable<T>, Zippable<T>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>

public class XorM<W1 extends WitnessType<W1>,W2 extends WitnessType<W2>,T>
extends java.lang.Object
implements Filters<T>, Transformable<T>, Folds<T>, Zippable<T>, org.reactivestreams.Publisher<T>, To<XorM<W1,W2,T>>

A Sum type for monads of the same type. XorM is active type biased (rather than right biased). e.g.

     
          XorM<stream,optional,Integer> nums = XorM.stream(1,2,3)
                                                     .swap();
          int result = nums.map(i->i*2)
                           .foldLeft(Monoids.intSum);
          //12

Constructor Summary

Constructors
Constructor and Description

XorM()

Constructors
Constructor and Description
`XorM()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<U> XorM<W1,W2,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream to a given type, possibly throwing a `ClassCastException`.
`<R> XorM<W1,W2,R>`	`coflatMap(java.util.function.Function<? super XorM<W1,W2,T>,R> mapper)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.completableFuture,T>`	`completableFutureOf(java.util.function.Supplier<T> value, java.util.concurrent.Executor ex)`
`static <W1 extends WitnessType<W1>,X extends java.lang.Throwable,T> XorM<W1,Witness.tryType,T>`	`failure(X value)`
`XorM<W1,W2,T>`	`filter(java.util.function.Predicate<? super T> test)` Keep only elements for which the supplied predicates hold e.g.
`XorM<W1,W2,T>`	`filterNot(java.util.function.Predicate<? super T> predicate)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.future,T>`	`futureOf(java.util.function.Supplier<T> value, java.util.concurrent.Executor ex)`
`java.util.Iterator<T>`	`iterator()`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.maybe,T>`	`just(T value)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.eval,T>`	`later(java.util.function.Supplier<T> value)`
`static <W1 extends WitnessType<W1>,W2 extends WitnessType<W2>,T> XorM<W1,W2,T>`	`left(AnyM<W1,T> left)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.linkedListX,T>`	`linkedListX(LinkedListX<T> list)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.linkedListX,T>`	`linkedListX(T... values)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.list,T>`	`listX(java.util.List<T> list)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.list,T>`	`listX(T... values)`
`<R> XorM<W1,W2,R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.maybe,T>`	`maybeNullabe(T value)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.maybe,T>`	`none()`
`XorM<W1,W2,T>`	`notNull()` Filter elements retaining only values which are not null
`static <W1 extends WitnessType<W1>,W2 extends WitnessType<W2>,T> XorM<W1,W2,T>`	`of(Xor<? extends AnyM<? extends W1,? extends T>,? extends AnyM<? extends W2,? extends T>> xor)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.optional,T>`	`ofNullable(T value)`
`<U> XorM<W1,W2,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a reactiveStream that are of a given type.
`XorM<W1,W2,T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.persistentSetX,T>`	`persistentsetX(PersistentSetX<T> list)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.persistentSetX,T>`	`persistentsetX(T... values)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.reactiveSeq,T>`	`reactiveSeq(ReactiveSeq<T> stream)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.reactiveSeq,T>`	`reactiveSeq(T... values)`
`<R> XorM<W1,W2,R>`	`retry(java.util.function.Function<? super T,? extends R> fn)` Retry a transformation if it fails.
`<R> XorM<W1,W2,R>`	`retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)` Retry a transformation if it fails.
`static <W1 extends WitnessType<W1>,W2 extends WitnessType<W2>,T> XorM<W1,W2,T>`	`right(AnyM<W2,T> right)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.set,T>`	`setX(java.util.Set<T> list)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.set,T>`	`setX(T... values)`
`ReactiveSeq<T>`	`stream()`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.stream,T>`	`stream(java.util.stream.Stream<T> stream)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.stream,T>`	`stream(T... values)`
`void`	`subscribe(org.reactivestreams.Subscriber<? super T> s)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.tryType,T>`	`success(T value)`
`XorM<W2,W1,T>`	`swap()`
`java.lang.String`	`toString()`
`<R> XorM<W1,W2,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
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.vectorX,T>`	`vectorX(T... values)`
`static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.vectorX,T>`	`vectorX(VectorX<T> list)`
`<R> R`	`visit(java.util.function.Function<? super AnyM<W1,? super T>,? extends R> left, java.util.function.Function<? super AnyM<W2,? super T>,? extends R> right)`
`XorM<W1,W2,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> XorM<W1,W2,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> XorM<W1,W2,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> XorM<W1,W2,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> XorM<W1,W2,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> XorM<W1,W2,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> XorM<W1,W2,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> XorM<W1,W2,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> XorM<W1,W2,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`<U> XorM<W1,W2,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> XorM<W1,W2,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> XorM<W1,W2,R>`	`zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)`
`<R> XorM<W1,W2,R>`	`zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)`
`<R> XorM<W1,W2,R>`	`zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)`

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

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 com.aol.cyclops2.types.foldable.To
to

Constructor Detail
- XorM
```
public XorM()
```

Method Detail

of

public static <W1 extends WitnessType<W1>,W2 extends WitnessType<W2>,T> XorM<W1,W2,T> of(Xor<? extends AnyM<? extends W1,? extends T>,? extends AnyM<? extends W2,? extends T>> xor)

right

public static <W1 extends WitnessType<W1>,W2 extends WitnessType<W2>,T> XorM<W1,W2,T> right(AnyM<W2,T> right)

left

public static <W1 extends WitnessType<W1>,W2 extends WitnessType<W2>,T> XorM<W1,W2,T> left(AnyM<W1,T> left)

filter
```
public XorM<W1,W2,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

coflatMap

public <R> XorM<W1,W2,R> coflatMap(java.util.function.Function<? super XorM<W1,W2,T>,R> mapper)

ofType

public <U> XorM<W1,W2,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 XorM<W1,W2,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 XorM<W1,W2,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

cast
```
public <U> XorM<W1,W2,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>

map
```
public <R> XorM<W1,W2,R> map(java.util.function.Function<? super T,? extends R> fn)
```
Description copied from interface: Transformable
Transform this functor using the supplied transformation function
```
 


    of(1,2,3).map(i->i*2)

    //[2,4,6]

 
 
```
Specified by:

map in interface Transformable<T>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

peek
```
public XorM<W1,W2,T> peek(java.util.function.Consumer<? super T> c)
```
Description copied from interface: Transformable
Peek at the current value of this Transformable, without transforming it
```
 


    of(1,2,3).map(System.out::println)

    1
    2
    3

 
 
```
Specified by:

peek in interface Transformable<T>

Parameters:

c - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

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

toString in class java.lang.Object

trampoline

public <R> XorM<W1,W2,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

retry

public <R> XorM<W1,W2,R> retry(java.util.function.Function<? super T,? extends R> fn)

Description copied from interface: Transformable

Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock)
 				.firstValue();

 		//result = 42

Specified by:: retry in interface Transformable<T>
Parameters:: fn - Function to retry if fails

retry

public <R> XorM<W1,W2,R> retry(java.util.function.Function<? super T,? extends R> fn,
                               int retries,
                               long delay,
                               java.util.concurrent.TimeUnit timeUnit)

Description copied from interface: Transformable

Retry a transformation if it fails. Retries up to retries times, with an doubling backoff period starting @ delay TimeUnits delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
 				.firstValue();

 		//result = 42

Specified by:: retry in interface Transformable<T>
Parameters:: fn - Function to retry if fails; retries - Number of retries; delay - Delay in TimeUnits; timeUnit - TimeUnit to use for delay

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

stream in interface Folds<T>

zip
```
public XorM<W1,W2,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>

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)); }

zipWith

public <R> XorM<W1,W2,R> zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)

Specified by:: zipWith in interface Zippable<T>

zipWithS

public <R> XorM<W1,W2,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> XorM<W1,W2,R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)

Specified by:: zipWithP in interface Zippable<T>

zip
```
public <T2,R> XorM<W1,W2,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>

Parameters:

iterable - to zip with

fn - Zip function

Returns:

Combined zippable

zipP
```
public <T2,R> XorM<W1,W2,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>

Parameters:

publisher - to combine with

fn - Zip / combining function

Returns:

Combined zippable

zipS
```
public <U,R> XorM<W1,W2,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

zipS
```
public <U> XorM<W1,W2,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>

Parameters:

other - Stream to combine with

Returns:

Combined Zippable

zipP

public <U> XorM<W1,W2,org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)

Specified by:: zipP in interface Zippable<T>

zip
```
public <U> XorM<W1,W2,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>

Parameters:

other - Iterable to combine with

Returns:

zip3

public <S,U> XorM<W1,W2,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> XorM<W1,W2,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> XorM<W1,W2,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> XorM<W1,W2,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>

subscribe
```
public void subscribe(org.reactivestreams.Subscriber<? super T> s)
```
Specified by:

subscribe in interface org.reactivestreams.Publisher<T>

visit

public <R> R visit(java.util.function.Function<? super AnyM<W1,? super T>,? extends R> left,
                   java.util.function.Function<? super AnyM<W2,? super T>,? extends R> right)

swap
```
public XorM<W2,W1,T> swap()
```

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

iterator in interface java.lang.Iterable<T>

vectorX

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.vectorX,T> vectorX(VectorX<T> list)

vectorX

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.vectorX,T> vectorX(T... values)

linkedListX

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.linkedListX,T> linkedListX(LinkedListX<T> list)

linkedListX

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.linkedListX,T> linkedListX(T... values)

persistentsetX

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.persistentSetX,T> persistentsetX(PersistentSetX<T> list)

persistentsetX

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.persistentSetX,T> persistentsetX(T... values)

setX

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.set,T> setX(java.util.Set<T> list)

setX

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.set,T> setX(T... values)

listX

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.list,T> listX(java.util.List<T> list)

listX

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.list,T> listX(T... values)

stream

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.stream,T> stream(java.util.stream.Stream<T> stream)

stream

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.stream,T> stream(T... values)

reactiveSeq

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.reactiveSeq,T> reactiveSeq(ReactiveSeq<T> stream)

reactiveSeq

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.reactiveSeq,T> reactiveSeq(T... values)

success

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.tryType,T> success(T value)

failure

public static <W1 extends WitnessType<W1>,X extends java.lang.Throwable,T> XorM<W1,Witness.tryType,T> failure(X value)

futureOf

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.future,T> futureOf(java.util.function.Supplier<T> value,
                                                                                java.util.concurrent.Executor ex)

completableFutureOf

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.completableFuture,T> completableFutureOf(java.util.function.Supplier<T> value,
                                                                                                      java.util.concurrent.Executor ex)

later

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.eval,T> later(java.util.function.Supplier<T> value)

ofNullable

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.optional,T> ofNullable(T value)

just

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.maybe,T> just(T value)

none

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.maybe,T> none()

maybeNullabe

public static <W1 extends WitnessType<W1>,T> XorM<W1,Witness.maybe,T> maybeNullabe(T value)

Class XorM<W1 extends WitnessType<W1>,W2 extends WitnessType<W2>,T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.Iterable

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

Constructor Detail

XorM

Method Detail

of

right

left

filter

coflatMap

ofType

filterNot

notNull

cast

map

peek

toString

trampoline

retry

retry

stream

zip

zipWith

zipWithS

zipWithP

zip

zipP

zipS

zipS

zipP

zip

zip3

zip3

zip4

zip4

subscribe

visit

swap

iterator

vectorX

vectorX

linkedListX

linkedListX

persistentsetX

persistentsetX

setX

setX

listX

listX

stream

stream

reactiveSeq

reactiveSeq

success

failure

futureOf

completableFutureOf

later

ofNullable

just

none

maybeNullabe