TryT (cyclops-try 7.2.3 API)

java.lang.Object
- com.aol.cyclops.trycatch.TryT<T,X>

Type Parameters:

T - The type contained on the Try within
```
public class TryT<T,X extends java.lang.Throwable>
extends java.lang.Object
```
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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`com.aol.cyclops.lambda.monads.transformers.OptionalT<T>`	`filter(java.util.function.Predicate<T> test)` Filter the wrapped Try
`<B> TryT<B,X>`	`flatMap(org.jooq.lambda.function.Function1<T,TryT<B,X>> f)` Flat Map the wrapped Try
`static <A,X extends java.lang.Throwable> TryT<A,X>`	`fromAnyM(com.aol.cyclops.monad.AnyM<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 <U,R,X extends java.lang.Throwable> java.util.function.Function<TryT<U,X>,TryT<R,X>>`	`lift(java.util.function.Function<U,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<TryT<U1,X>,TryT<U2,X>,TryT<R,X>>`	`lift2(java.util.function.BiFunction<U1,U2,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> TryT<B,X>`	`map(java.util.function.Function<T,B> f)` Map the wrapped Try
`static <A,X extends java.lang.Throwable> TryT<A,X>`	`of(com.aol.cyclops.monad.AnyM<Try<A,X>> monads)` Construct an TryT from an AnyM that wraps a monad containing Trys
`TryT<T,X>`	`peek(java.util.function.Consumer<T> peek)` Peek at the current value of the Try
`java.lang.String`	`toString()`
`com.aol.cyclops.monad.AnyM<Try<T,X>>`	`unwrap()`

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

Method Detail

unwrap

public com.aol.cyclops.monad.AnyM<Try<T,X>> unwrap()

Returns:: The wrapped AnyM

peek

public TryT<T,X> peek(java.util.function.Consumer<T> peek)

Peek at the current value of the Try

  
    TryT.of(AnyM.fromStream(Success.of(10))
             .peek(System.out::println);
             
     //prints 10

Parameters:: peek - Consumer to accept current value of Try
Returns:: TryT with peek call

filter

public com.aol.cyclops.lambda.monads.transformers.OptionalT<T> filter(java.util.function.Predicate<T> test)

Filter the wrapped Try

  
    TryT.of(AnyM.fromStream(Success.of(10))
             .filter(t->t!=10);
             
     //TryT<AnyM<Stream<Optional.empty>>>

Parameters:: test - Predicate to filter the wrapped Try
Returns:: OptionalT that applies the provided filter

map

public <B> TryT<B,X> map(java.util.function.Function<T,B> f)

Map the wrapped Try

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

Parameters:: f - Mapping function for the wrapped Try
Returns:: TryT that applies the map function to the wrapped Try

flatMap

public <B> TryT<B,X> flatMap(org.jooq.lambda.function.Function1<T,TryT<B,X>> f)

Flat Map the wrapped Try

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

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

lift

public static <U,R,X extends java.lang.Throwable> java.util.function.Function<TryT<U,X>,TryT<R,X>> lift(java.util.function.Function<U,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);
		AnyM<Integer> stream = AnyM.ofMonad(withNulls);
		AnyM<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);

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<TryT<U1,X>,TryT<U2,X>,TryT<R,X>> lift2(java.util.function.BiFunction<U1,U2,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);
		AnyM<Integer> stream = AnyM.ofMonad(withNulls);
		AnyM<Try<Integer,RuntimeException>> streamOpt = stream.map(this::toTry);
		
		CompletableFuture<Try<Integer,RuntimeException>> two = CompletableFuture.completedFuture(Try.of(2));
		AnyM<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);

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> TryT<A,X> fromAnyM(com.aol.cyclops.monad.AnyM<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> TryT<A,X> of(com.aol.cyclops.monad.AnyM<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

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

toString in class java.lang.Object

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