XorT (simple-react 1.0.0-RC4 API)

Type Parameters:

T - The type contained on the Xor within

All Superinterfaces:

Filterable<T>, Functor<T>, org.reactivestreams.Publisher<T>

All Known Implementing Classes:

XorTSeq, XorTValue
```
public interface XorT<ST,T>
extends org.reactivestreams.Publisher<T>, Functor<T>, Filterable<T>
```
Monad transformer for JDK Xor XorT consists of an AnyM instance that in turns wraps anoter Monad type that contains an Xor XorT>>> XorT allows the deeply wrapped Xor to be manipulating within it's nested /contained context

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <B> XorT<ST,B>`	`bind(java.util.function.Function<? super T,XorT<ST,? extends B>> f)` Flat Map the wrapped Xor
`default <U> XorT<ST,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`<R> XorT<ST,R>`	`empty()`
`static <ST,T> XorTSeq<ST,T>`	`emptyList()`
`static <ST,PT> XorTValue<ST,PT>`	`emptyOptional()`
`XorT<ST,T>`	`filter(java.util.function.Predicate<? super T> test)` Filter the wrapped Xor
`default XorT<ST,T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<ST2,B> XorT<ST2,B>`	`flatMap(java.util.function.Function<? super T,? extends MonadicValue2<? extends ST2,? extends B>> f)`
`static <ST,A> XorT<ST,A>`	`fromAnyM(AnyM<A> anyM)` Construct an XorT from an AnyM that contains a monad type that contains type other than Xor The values in the underlying monad will be mapped to Xor
`static <ST,A> XorTSeq<ST,A>`	`fromAnyMSeq(AnyMSeq<A> anyM)`
`static <ST,A> XorTValue<ST,A>`	`fromAnyMValue(AnyMValue<A> anyM)`
`static <ST,A> XorTValue<ST,A>`	`fromFuture(java.util.concurrent.CompletableFuture<Xor<ST,A>> future)`
`static <ST,A> XorTSeq<ST,A>`	`fromIterable(java.lang.Iterable<Xor<ST,A>> iterableOfXors)`
`static <ST,A> XorTValue<ST,A>`	`fromIterablXorue(java.lang.Iterable<Xor<ST,A>> iterableOfXors)`
`static <ST,A> XorTValue<ST,A>`	`fromOptional(java.util.Optional<Xor<ST,A>> optional)`
`static <ST,A> XorTSeq<ST,A>`	`fromPublisher(org.reactivestreams.Publisher<Xor<ST,A>> publisherOfXors)`
`static <ST,A> XorTSeq<ST,A>`	`fromStream(java.util.stream.Stream<Xor<ST,A>> streamOfXors)`
`static <A,ST,V extends MonadicValue<Xor<ST,A>>> XorTValue<ST,A>`	`fromValue(V monadicValue)`
`static <ST,U,R> java.util.function.Function<XorT<ST,U>,XorT<ST,R>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an XorT This allows multiple monad types to add functionality to existing functions and methods e.g.
`static <ST,U1,U2,R> java.util.function.BiFunction<XorT<ST,U1>,XorT<ST,U2>,XorT<ST,R>>`	`lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)` Lift a BiFunction into one that accepts and returns XorTs This allows multiple monad types to add functionality to existing functions and methods e.g.
`<B> XorT<ST,B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped Xor
`default XorT<ST,T>`	`notNull()` Filter elements retaining only values which are not null
`static <ST,A> XorT<ST,A>`	`of(AnyM<Xor<ST,A>> monads)` Construct an XorT from an AnyM that wraps a monad containing Xors
`default <U> XorT<ST,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default <R> XorT<ST,R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`XorT<ST,T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the Xor
`XorT<T,ST>`	`swap()`
`default <R> XorT<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
`<R> XorT<ST,R>`	`unit(R value)`
`AnyM<Xor<ST,T>>`	`unwrap()`

Methods inherited from interface org.reactivestreams.Publisher
subscribe

Method Detail

unit
```
<R> XorT<ST,R> unit(R value)
```

empty
```
<R> XorT<ST,R> empty()
```

flatMap

<ST2,B> XorT<ST2,B> flatMap(java.util.function.Function<? super T,? extends MonadicValue2<? extends ST2,? extends B>> f)

unwrap
```
AnyM<Xor<ST,T>> unwrap()
```
Returns:

The wrapped AnyM

peek

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

Peek at the current value of the Xor

  
    XorT.of(AnyM.fromStream(Xor.of(10))
             .peek(System.out::println);
             
     //prints 10

Specified by:: peek in interface Functor<T>
Parameters:: peek - Consumer to accept current value of Xor
Returns:: XorT with peek call

filter

XorT<ST,T> filter(java.util.function.Predicate<? super T> test)

Filter the wrapped Xor

  
    XorT.of(AnyM.fromStream(Xor.of(10))
             .filter(t->t!=10);
             
     //XorT<AnyM<Stream<Xor.empty>>>

Specified by:: filter in interface Filterable<T>
Parameters:: test - Predicate to filter the wrapped Xor
Returns:: XorT that applies the provided filter

map

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

Map the wrapped Xor

  
  XorT.of(AnyM.fromStream(Xor.of(10))
             .map(t->t=t+1);
  
  
  //XorT<AnyM<Stream<Xor[11]>>>

Specified by:: map in interface Functor<T>
Parameters:: f - Mapping function for the wrapped Xor
Returns:: XorT that applies the map function to the wrapped Xor

bind

default <B> XorT<ST,B> bind(java.util.function.Function<? super T,XorT<ST,? extends B>> f)

Flat Map the wrapped Xor

  
  XorT.of(AnyM.fromStream(Xor.of(10))
             .flatMap(t->Xor.empty();
  
  
  //XorT<AnyM<Stream<Xor.empty>>>

Parameters:: f - FlatMap function
Returns:: XorT that applies the flatMap function to the wrapped Xor

swap
```
XorT<T,ST> swap()
```

lift

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

Lift a function into one that accepts and returns an XorT This allows multiple monad types to add functionality to existing functions and methods e.g. to add null handling (via Xor) and iteration (via Stream) to an existing function

 {
     @code
     Function add2 = i -> i + 2;
     Function, XorT> optTAdd2 = XorT.lift(add2);
 
     Stream withNulls = Stream.of(1, 2, null);
     AnyM stream = AnyM.ofMonad(withNulls);
     AnyM> streamOpt = stream.map(Xor::ofNullable);
     List results = optTAdd2.apply(XorT.of(streamOpt)).unwrap().>> unwrap()
             .filter(Xor::isPresent).map(Xor::get).collect(Collectors.toList());
 
     // Arrays.asList(3,4);
 
 }

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

lift2

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

Lift a BiFunction into one that accepts and returns XorTs This allows multiple monad types to add functionality to existing functions and methods e.g. to add null handling (via Xor), iteration (via Stream) and asynchronous execution (CompletableFuture) to an existing function

 {
     @code
     BiFunction add = (a, b) -> a + b;
     BiFunction, XorT, XorT> optTAdd2 = XorT.lift2(add);
 
     Stream withNulls = Stream.of(1, 2, null);
     AnyM stream = AnyM.ofMonad(withNulls);
     AnyM> streamOpt = stream.map(Xor::ofNullable);
 
     CompletableFuture> two = CompletableFuture.supplyAsync(() -> Xor.of(2));
     AnyM> future = AnyM.ofMonad(two);
     List results = optTAdd2.apply(XorT.of(streamOpt), XorT.of(future)).unwrap()
             .>> unwrap().filter(Xor::isPresent).map(Xor::get)
             .collect(Collectors.toList());
     // Arrays.asList(3,4);
 }

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

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

Parameters:

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

Returns:

XorT

of
```
static <ST,A> XorT<ST,A> of(AnyM<Xor<ST,A>> monads)
```
Construct an XorT from an AnyM that wraps a monad containing Xors

Parameters:

monads - AnyM that contains a monad wrapping an Xor

Returns:

XorT

fromAnyMValue

static <ST,A> XorTValue<ST,A> fromAnyMValue(AnyMValue<A> anyM)

fromAnyMSeq

static <ST,A> XorTSeq<ST,A> fromAnyMSeq(AnyMSeq<A> anyM)

fromIterable

static <ST,A> XorTSeq<ST,A> fromIterable(java.lang.Iterable<Xor<ST,A>> iterableOfXors)

fromStream

static <ST,A> XorTSeq<ST,A> fromStream(java.util.stream.Stream<Xor<ST,A>> streamOfXors)

fromPublisher

static <ST,A> XorTSeq<ST,A> fromPublisher(org.reactivestreams.Publisher<Xor<ST,A>> publisherOfXors)

fromValue

static <A,ST,V extends MonadicValue<Xor<ST,A>>> XorTValue<ST,A> fromValue(V monadicValue)

fromOptional

static <ST,A> XorTValue<ST,A> fromOptional(java.util.Optional<Xor<ST,A>> optional)

fromFuture

static <ST,A> XorTValue<ST,A> fromFuture(java.util.concurrent.CompletableFuture<Xor<ST,A>> future)

fromIterablXorue

static <ST,A> XorTValue<ST,A> fromIterablXorue(java.lang.Iterable<Xor<ST,A>> iterableOfXors)

emptyOptional

static <ST,PT> XorTValue<ST,PT> emptyOptional()

emptyList

static <ST,T> XorTSeq<ST,T> emptyList()

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

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

Specified by:

cast in interface Functor<T>

trampoline

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

Description copied from interface: Functor

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 Functor<T>
Returns:

patternMatch

default <R> XorT<ST,R> patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1,
                                    java.util.function.Supplier<? extends R> otherwise)

Description copied from interface: Functor

Transform the elements of this Stream with a Pattern Matching case and default value

 
 List<String> result = CollectionX.of(1,2,3,4)
                                              .patternMatch(
                                                        c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
                                                      )
 
 // CollectionX["odd","even","odd","even"]

Specified by:: patternMatch in interface Functor<T>
Parameters:: case1 - Function to generate a case (or chain of cases as a single case); otherwise - Value if supplied case doesn't match
Returns:: CollectionX where elements are transformed by pattern matching

ofType

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

Description copied from interface: Filterable

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

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

Specified by:: ofType in interface Filterable<T>

filterNot
```
default XorT<ST,T> filterNot(java.util.function.Predicate<? super T> fn)
```
Description copied from interface: Filterable
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 Filterable<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

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

notNull in interface Filterable<T>

Returns:

Filterable with nulls removed

Interface XorT<ST,T>