TryTValue (simple-react 1.0.0-RC4 API)

java.lang.Object
- com.aol.cyclops.control.monads.transformers.values.TryTValue<T,X>

Type Parameters:

T - The type contained on the Try within

All Implemented Interfaces:

Matchable.MatchableOptional<T>, Matchable.ValueAndOptionalMatcher<T>, TryT<T,X>, TransformerValue<T>, ApplicativeFunctor<T>, Convertable<T>, ConvertableFunctor<T>, Filterable<T>, Foldable<T>, Functor<T>, MonadicValue<T>, Unit<T>, Value<T>, Visitable<T>, java.lang.Iterable<T>, java.util.function.Predicate<T>, java.util.function.Supplier<T>, org.reactivestreams.Publisher<T>
```
public class TryTValue<T,X extends java.lang.Throwable>
extends java.lang.Object
implements TryT<T,X>, TransformerValue<T>, MonadicValue<T>, java.util.function.Supplier<T>, ConvertableFunctor<T>, Filterable<T>, ApplicativeFunctor<T>, Matchable.ValueAndOptionalMatcher<T>
```
Monad transformer for JDK Try TryT consists of an AnyM instance that in turns wraps another Monad type that contains an Try TryT>>> TryT allows the deeply wrapped Try to be manipulating within it's nested /contained context

Nested Class Summary
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor
  ApplicativeFunctor.Applicatives, ApplicativeFunctor.ApplyFunctions<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Value
  Value.ValueImpl<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Convertable
  Convertable.SupplierToConvertable<T>

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T2,R> TryTValue<R,X>`	`ap(Value<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)`
`<U> TryTValue<U,X>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`<R> TryTValue<R,X>`	`empty()`
`static <T,X extends java.lang.Throwable> TryTValue<T,X>`	`emptyOptional()`
`boolean`	`equals(java.lang.Object o)`
`MaybeTValue<T>`	`filter(java.util.function.Predicate<? super T> test)` Filter the wrapped Try
`MaybeTValue<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<B> TryTValue<B,X>`	`flatMap(java.util.function.Function<? super T,? extends Try<B,X>> f)`
`<B> TryTValue<B,X>`	`flatMapT(java.util.function.Function<? super T,TryTValue<B,X>> f)` Flat Map the wrapped Try
`static <A,X extends java.lang.Throwable> TryTValue<A,X>`	`fromAnyM(AnyMValue<A> anyM)` Construct an TryT from an AnyM that contains a monad type that contains type other than Try The values in the underlying monad will be mapped to Try
`static <A,X extends java.lang.Throwable,V extends MonadicValue<Try<A,X>>> TryTValue<A,X>`	`fromValue(V monadicValue)`
`T`	`get()`
`int`	`hashCode()`
`boolean`	`isFailure()`
`boolean`	`isSuccess()`
`boolean`	`isValuePresent()`
`java.util.Iterator<T>`	`iterator()`
`static <U,R,X extends java.lang.Throwable> java.util.function.Function<TryTValue<U,X>,TryTValue<R,X>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an TryT This allows multiple monad types to add functionality to existing functions and methods e.g.
`static <U1,U2,R,X extends java.lang.Throwable> java.util.function.BiFunction<TryTValue<U1,X>,TryTValue<U2,X>,TryTValue<R,X>>`	`lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)` Lift a BiFunction into one that accepts and returns TryTs This allows multiple monad types to add functionality to existing functions and methods e.g.
`<B> TryTValue<B,X>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped Try
`MaybeTValue<T>`	`notNull()` Filter elements retaining only values which are not null
`static <A,X extends java.lang.Throwable> TryTValue<A,X>`	`of(AnyMValue<Try<A,X>> monads)` Construct an TryT from an AnyM that wraps a monad containing Trys
`static <A,X extends java.lang.Throwable> TryTValue<A,X>`	`of(Try<A,X> monads)`
`<U> MaybeTValue<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`<R> TryTValue<R,X>`	`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
`TryTValue<T,X>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the Try
`ReactiveSeq<T>`	`stream()`
`void`	`subscribe(org.reactivestreams.Subscriber<? super T> s)`
`boolean`	`test(T t)`
`java.lang.String`	`toString()`
`<R> TryTValue<R,X>`	`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> TryTValue<R,X>`	`unit(R value)`
`AnyMValue<Try<T,X>>`	`unwrap()`
`Try<T,X>`	`value()`
`<R> R`	`visit(java.util.function.Function<? super T,? extends R> success, java.util.function.Function<? super X,? extends R> failure, java.util.function.Supplier<R> none)`
`<T2,R> TryTValue<R,X>`	`zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app)`
`<T2,R> TryTValue<R,X>`	`zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)`

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

Methods inherited from interface com.aol.cyclops.control.monads.transformers.TryT
bind, emptyList, fromAnyM, fromAnyMSeq, fromAnyMValue, fromFuture, fromIterable, fromIterablTryue, fromOptional, fromPublisher, fromStream, of

Methods inherited from interface com.aol.cyclops.control.monads.transformers.values.TransformerValue
isPresent

Methods inherited from interface com.aol.cyclops.types.MonadicValue
anyM, coflatMap, nest

Methods inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor
applyFunctions

Methods inherited from interface com.aol.cyclops.types.Value
collect, fold, fold, generate, iterate, mapReduce, mkString, newSubscriber, of, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFeatureToggle, toFutureStream, toFutureStream, toIor, toLazyImmutable, toList, toListX, toMaybe, toMutable, toPBagX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toTry, toTry, toTry, toXor, toXor, unapply

Methods inherited from interface com.aol.cyclops.types.Foldable
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, xMatch

Methods inherited from interface com.aol.cyclops.types.Convertable
collect, fromSupplier, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toFutureWAsync, toFutureWAsync, toOptional, toOptionalAtomicReference, toStream, visit

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

Methods inherited from interface java.util.function.Predicate
and, isEqual, negate, or

Methods inherited from interface com.aol.cyclops.control.Matchable.ValueAndOptionalMatcher
toOptional, visit

Methods inherited from interface com.aol.cyclops.control.Matchable.MatchableOptional
matches

Method Detail

value
```
public Try<T,X> value()
```
Specified by:

value in interface TransformerValue<T>

isValuePresent
```
public boolean isValuePresent()
```
Specified by:

isValuePresent in interface TransformerValue<T>

unwrap
```
public AnyMValue<Try<T,X>> unwrap()
```
Specified by:

unwrap in interface TryT<T,X extends java.lang.Throwable>

Returns:

The wrapped AnyM

peek
```
public TryTValue<T,X> peek(java.util.function.Consumer<? super T> peek)
```
Peek at the current value of the Try
```
  
    TryT.of(AnyM.fromStream(Try.success(10))
             .peek(System.out::println);
             
     //prints 10        
 
 
```
Specified by:

peek in interface TryT<T,X extends java.lang.Throwable>

Specified by:

peek in interface TransformerValue<T>

Specified by:

peek in interface Functor<T>

Parameters:

peek - Consumer to accept current value of Try

Returns:

TryT with peek call

filter
```
public MaybeTValue<T> filter(java.util.function.Predicate<? super T> test)
```
Filter the wrapped Try
```
  
    TryT.of(AnyM.fromStream(Try.success(10))
             .filter(t->t!=10);
             
     //TryT<AnyMValue<Stream<Optional.empty>>>
 
 
```
Specified by:

filter in interface TryT<T,X extends java.lang.Throwable>

Specified by:

filter in interface TransformerValue<T>

Specified by:

filter in interface Filterable<T>

Parameters:

test - Predicate to filter the wrapped Try

Returns:

OptionalT that applies the provided filter

map
```
public <B> TryTValue<B,X> map(java.util.function.Function<? super T,? extends B> f)
```
Map the wrapped Try
```
  
  TryT.of(AnyM.fromStream(Try.success(10))
             .map(t->t=t+1);
  
  
  //TryT<AnyMValue<Stream<Success[11]>>>
 
 
```
Specified by:

map in interface TryT<T,X extends java.lang.Throwable>

Specified by:

map in interface TransformerValue<T>

Specified by:

map in interface ConvertableFunctor<T>

Specified by:

map in interface Functor<T>

Specified by:

map in interface MonadicValue<T>

Parameters:

f - Mapping function for the wrapped Try

Returns:

TryT that applies the map function to the wrapped Try

ap

public <T2,R> TryTValue<R,X> ap(Value<? extends T2> app,
                                java.util.function.BiFunction<? super T,? super T2,? extends R> fn)

Specified by:: ap in interface ApplicativeFunctor<T>

zip

public <T2,R> TryTValue<R,X> zip(java.lang.Iterable<? extends T2> app,
                                 java.util.function.BiFunction<? super T,? super T2,? extends R> fn)

Specified by:: zip in interface ApplicativeFunctor<T>

zip

public <T2,R> TryTValue<R,X> zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn,
                                 org.reactivestreams.Publisher<? extends T2> app)

Specified by:: zip in interface ApplicativeFunctor<T>

flatMapT

public <B> TryTValue<B,X> flatMapT(java.util.function.Function<? super T,TryTValue<B,X>> f)

Flat Map the wrapped Try

  
  TryT.of(AnyM.fromStream(Try.success(10))
             .flatMap(t->Try.failure(new Exception());
  
  
  //TryT<AnyMValue<Stream<Failure[Excption]>>>

Parameters:: f - FlatMap function
Returns:: TryT that applies the flatMap function to the wrapped Try

flatMap

public <B> TryTValue<B,X> flatMap(java.util.function.Function<? super T,? extends Try<B,X>> f)

Specified by:: flatMap in interface TryT<T,X extends java.lang.Throwable>

lift

public static <U,R,X extends java.lang.Throwable> java.util.function.Function<TryTValue<U,X>,TryTValue<R,X>> lift(java.util.function.Function<? super U,? extends R> fn)

Lift a function into one that accepts and returns an TryT This allows multiple monad types to add functionality to existing functions and methods e.g. to add Exception Handling (via Try) and iteration (via Stream) to an existing function

  
  Function<Integer,Integer> add2 = i -> i+2;
		Function<TryT<Integer,RuntimeException>, TryT<Integer,RuntimeException>> optTAdd2 = TryT.lift(add2);
		
		Stream<Integer> withNulls = Stream.of(1,2,null);
		AnyMValue<Integer> stream = AnyM.ofMonad(withNulls);
		AnyMValue<Try<Integer,RuntimeException>> streamOpt = stream.map(this::toTry);
		List<Integer> results = optTAdd2.apply(TryT.of(streamOpt))
										.unwrap()
										.<Stream<Try<Integer,RuntimeException>>>unwrap()
										.filter(Try::isSuccess)
										.map(Try::get)
										.collect(Collectors.toList());
		
		//Arrays.asList(3,4);

Specified by:: lift in interface TryT<T,X extends java.lang.Throwable>
Parameters:: fn - Function to enhance with functionality from Try and another monad type
Returns:: Function that accepts and returns an TryT

lift2

public static <U1,U2,R,X extends java.lang.Throwable> java.util.function.BiFunction<TryTValue<U1,X>,TryTValue<U2,X>,TryTValue<R,X>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)

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

  
	BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;
		BiFunction<TryT<Integer,RuntimeException>,TryT<Integer,RuntimeException>, TryT<Integer,RuntimeException>> optTAdd2 = TryT.lift2(add);
		
		Stream<Integer> withNulls = Stream.of(1,2,null);
		AnyMValue<Integer> stream = AnyM.ofMonad(withNulls);
		AnyMValue<Try<Integer,RuntimeException>> streamOpt = stream.map(this::toTry);
		
		CompletableFuture<Try<Integer,RuntimeException>> two = CompletableFuture.completedFuture(Try.of(2));
		AnyMValue<Try<Integer,RuntimeException>> future=  AnyM.ofMonad(two);
		List<Integer> results = optTAdd2.apply(TryT.of(streamOpt),TryT.of(future))
										.unwrap()
										.<Stream<Try<Integer,RuntimeException>>>unwrap()
										.filter(Try::isSuccess)
										.map(Try::get)
										.collect(Collectors.toList());
			//Arrays.asList(3,4);

Specified by:: lift2 in interface TryT<T,X extends java.lang.Throwable>
Parameters:: fn - BiFunction to enhance with functionality from Try and another monad type
Returns:: Function that accepts and returns an TryT

fromAnyM
```
public static <A,X extends java.lang.Throwable> TryTValue<A,X> fromAnyM(AnyMValue<A> anyM)
```
Construct an TryT from an AnyM that contains a monad type that contains type other than Try The values in the underlying monad will be mapped to Try

Parameters:

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

Returns:

TryT

of
```
public static <A,X extends java.lang.Throwable> TryTValue<A,X> of(AnyMValue<Try<A,X>> monads)
```
Construct an TryT from an AnyM that wraps a monad containing Trys

Parameters:

monads - AnyM that contains a monad wrapping an Try

Returns:

TryT

of

public static <A,X extends java.lang.Throwable> TryTValue<A,X> of(Try<A,X> monads)

fromValue

public static <A,X extends java.lang.Throwable,V extends MonadicValue<Try<A,X>>> TryTValue<A,X> fromValue(V monadicValue)

Specified by:: fromValue in interface TryT<T,X extends java.lang.Throwable>

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

toString in class java.lang.Object

get
```
public T get()
```
Specified by:

get in interface Convertable<T>

Specified by:

get in interface java.util.function.Supplier<T>

Returns:

Contained value, maybe null

isSuccess
```
public boolean isSuccess()
```

isFailure
```
public boolean isFailure()
```

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

stream in interface Foldable<T>

Specified by:

stream in interface Value<T>

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

iterator in interface Matchable.MatchableOptional<T>

Specified by:

iterator in interface Matchable.ValueAndOptionalMatcher<T>

Specified by:

iterator in interface Convertable<T>

Specified by:

iterator in interface java.lang.Iterable<T>

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

subscribe in interface Value<T>

Specified by:

subscribe in interface org.reactivestreams.Publisher<T>

test
```
public boolean test(T t)
```
Specified by:

test in interface Value<T>

Specified by:

test in interface java.util.function.Predicate<T>

visit

public <R> R visit(java.util.function.Function<? super T,? extends R> success,
                   java.util.function.Function<? super X,? extends R> failure,
                   java.util.function.Supplier<R> none)

unit
```
public <R> TryTValue<R,X> unit(R value)
```
Specified by:

unit in interface TryT<T,X extends java.lang.Throwable>

Specified by:

unit in interface TransformerValue<T>

Specified by:

unit in interface MonadicValue<T>

Specified by:

unit in interface Unit<T>

empty
```
public <R> TryTValue<R,X> empty()
```
Specified by:

empty in interface TryT<T,X extends java.lang.Throwable>

emptyOptional
```
public static <T,X extends java.lang.Throwable> TryTValue<T,X> emptyOptional()
```
Specified by:

emptyOptional in interface TryT<T,X extends java.lang.Throwable>

cast
```
public <U> TryTValue<U,X> 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 TryT<T,X extends java.lang.Throwable>

Specified by:

cast in interface TransformerValue<T>

Specified by:

cast in interface Functor<T>

trampoline

public <R> TryTValue<R,X> 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 TryT<T,X extends java.lang.Throwable>
Specified by:: trampoline in interface TransformerValue<T>
Specified by:: trampoline in interface Functor<T>
Returns:

patternMatch

public <R> TryTValue<R,X> 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 TryT<T,X extends java.lang.Throwable>
Specified by:: patternMatch in interface TransformerValue<T>
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
```
public <U> MaybeTValue<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 TryT<T,X extends java.lang.Throwable>

Specified by:

ofType in interface Filterable<T>

filterNot
```
public MaybeTValue<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 TryT<T,X extends java.lang.Throwable>

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
```
public MaybeTValue<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 TryT<T,X extends java.lang.Throwable>

Specified by:

notNull in interface Filterable<T>

Returns:

Filterable with nulls removed

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

Class TryTValue<T,X extends java.lang.Throwable>

Nested Class Summary

Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

Nested classes/interfaces inherited from interface com.aol.cyclops.types.Value

Nested classes/interfaces inherited from interface com.aol.cyclops.types.Convertable

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops.control.monads.transformers.TryT

Methods inherited from interface com.aol.cyclops.control.monads.transformers.values.TransformerValue

Methods inherited from interface com.aol.cyclops.types.MonadicValue

Methods inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

Methods inherited from interface com.aol.cyclops.types.Value

Methods inherited from interface com.aol.cyclops.types.Foldable

Methods inherited from interface com.aol.cyclops.types.Convertable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.function.Predicate

Methods inherited from interface com.aol.cyclops.control.Matchable.ValueAndOptionalMatcher

Methods inherited from interface com.aol.cyclops.control.Matchable.MatchableOptional

Method Detail

value

isValuePresent

unwrap

peek

filter

map

ap

zip

zip

flatMapT

flatMap

lift

lift2

fromAnyM

of

of

fromValue

toString

get

isSuccess

isFailure

stream

iterator

subscribe

test

visit

unit

empty

emptyOptional

cast

trampoline

patternMatch

ofType

filterNot

notNull

hashCode

equals