com.aol.cyclops.control

Interface Try<T,X extends java.lang.Throwable>

Type Parameters:

T - Return type (success)

X - Base Error type

All Superinterfaces:

ApplicativeFunctor<T>, Combiner<T>, Convertable<T>, ConvertableFunctor<T>, ConvertableToReactiveSeq<T>, Filterable<T>, Foldable<T>, Functor<T>, java.lang.Iterable<T>, MonadicValue<T>, java.util.function.Predicate<T>, org.reactivestreams.Publisher<T>, java.util.function.Supplier<T>, To<Try<T,X>>, ToStream<T>, Unit<T>, Value<T>, Visitable<T>, Zippable<T>

All Known Implementing Classes:

Try.Failure, Try.Success

public interface Try<T,X extends java.lang.Throwable>
extends To<Try<T,X>>, java.util.function.Supplier<T>, MonadicValue<T>, ToStream<T>, Filterable<T>, Functor<T>, ApplicativeFunctor<T>

Light weight Try Monad Fail fast behaviour with more explicit declararions required compared to with scala.util.Try and javaslang.monad.Try. This is probably closer to how most Java devs currently handle exceptions. Goals / features Support for init block / try block / finally block Try with resources Try with multiple resources Does not automatically catch exceptions in combinators Can target specific exception types Exception types to be caught can be specified in xxxWithCatch methods Handle exceptions conciously, not coding bugs Fluent step builders Fail fast Examples : Create a 'successful' value

  
  Try.success("return-value");
 
 

Create a failure value

  
  Try.failure(new MyException("error details"));
 
 

Exceute methods that may throw exceptions Non-void methods

  
 
 Try.withCatch(()-> exceptional2())
                        .map(i->i+" woo!")
                        .onFail(System.out::println)
                        .orElse("default");
                        
  //"hello world woo!"
 
  private String exceptional2() throws RuntimeException{
        return "hello world";
    }
 
 

Void methods

  
   
   
  //Only catch IOExceptions
  
  Try.runWithCatch(this::exceptional,IOException.class)
        .onFail(System.err::println);
        
    private void exceptional() throws IOException{
        throw new IOException();
    }
 
 
 

Try with resources

  
    
   Try.catchExceptions(FileNotFoundException.class,IOException.class)
         .init(()->new BufferedReader(new FileReader("file.txt")))
         .tryWithResources(this::read)
         .map(this::processData)
         .recover(e->"default);
  
 
 

By default Try does not catch exception within it's operators such as map / flatMap, to catch Exceptions in ongoing operations use @see of(Object, Class...)

  
  Try.of(2, RuntimeException.class)
       .map(i->{throw new RuntimeException();});
       
    //Failure[RuntimeException]   
 
 
 

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	Try.AndFinally<T,V,X extends java.lang.Throwable>
static interface	Try.CheckedConsumer<T,X extends java.lang.Throwable>
static interface	Try.CheckedFunction<T,R,X extends java.lang.Throwable>
static interface	Try.CheckedRunnable<X extends java.lang.Throwable>
static interface	Try.CheckedSupplier<T,X extends java.lang.Throwable>
static class	Try.Failure<T,X extends java.lang.Throwable> Class that represents the Failure of a Try
static interface	Try.Init<X extends java.lang.Throwable>
static class	Try.MyFinallyBlock<T,V,X extends java.lang.Throwable>
static class	Try.MyInit<X extends java.lang.Throwable>
static class	Try.MyTryCatch<V,X extends java.lang.Throwable>
static class	Try.Success<T,X extends java.lang.Throwable> Class that represents a Successful Try
static interface	Try.TryCatch<V,X extends java.lang.Throwable>

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

Modifier and Type	Method and Description
AnyMValue<T>	anyM()
AnyM<X>	anyMFailure()
AnyM<T>	anyMSuccess()
default <U> Try<U,X>	cast(java.lang.Class<? extends U> type) Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
static <X extends java.lang.Throwable> Try.Init<X>	catchExceptions(java.lang.Class<? extends X>... classes) Fluent step builder for Try / Catch / Finally and Try with resources equivalents.
default <R> Try<R,X>	coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper) Perform a coflatMap operation.
default Combiner<T>	combine(java.util.function.BinaryOperator<Combiner<T>> combiner, Combiner<T> app) Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout Semigroups and Monoids for a large number of canned combinations).
default Try<T,X>	combine(Monoid<T> monoid, Try<? extends T,X> v2) Combine this Try with another using the supplied Monoid as a combiner
default <T2,R> Try<R,X>	combine(Value<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn) Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example
static <T,X extends java.lang.Throwable> Try.Failure<T,X>	failure(X error) Construct a Failure instance from a throwable (an implementation of Try)
X	failureGet()
Maybe<T>	filter(java.util.function.Predicate<? super T> p) Keep only elements for which the supplied predicates hold e.g.
default Maybe<T>	filterNot(java.util.function.Predicate<? super T> fn) Remove any elements for which the predicate holds (inverse operation to filter) e.g.
<R> Try<R,X>	flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> fn) A flattening transformation operation (@see Optional.flatMap(Function)
Try<T,X>	flatten() Flatten a nested Try Structure
void	forEach(java.util.function.Consumer<? super T> consumer)
default <R1,R> Try<R,X>	forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue
default <R1,R> Try<R,X>	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) Perform a two level nested internal iteration over this MonadicValue and the supplied stream
default <T2,R1,R2,R> Try<R,X>	forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, TriFunction<? super T,? super R1,? super R2,? extends R> yieldingFunction) Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
default <T2,R1,R2,R> Try<R,X>	forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, TriFunction<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, TriFunction<? super T,? super R1,? super R2,? extends R> yieldingFunction) Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
default <T2,R1,R2,R3,R> Try<R,X>	forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, TriFunction<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, QuadFunction<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues
default <T2,R1,R2,R3,R> Try<R,X>	forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, TriFunction<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, QuadFunction<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, QuadFunction<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues Maybe.of(3) .forEach4(a->Maybe.just(a+10), (a,b)->Maybe.just(a+b), (a,b,c)->Maybe.none(), (a,b,c,d)->a+b+c<100, (a,b,c,d)->a+b+c+d); //Maybe.none
void	forEachFailed(java.util.function.Consumer<? super X> consumer)
static <T,X extends java.lang.Throwable> Try<T,X>	fromIterable(java.lang.Iterable<T> iterable) Construct a Try that contains a single value extracted from the supplied Iterable
static <T> Try<T,java.lang.Throwable>	fromPublisher(org.reactivestreams.Publisher<T> pub) Construct a Try that contains a single value extracted from the supplied reactive-streams Publisher
static <T,X extends java.lang.Throwable> Try<T,X>	fromPublisher(org.reactivestreams.Publisher<T> pub, java.lang.Class<X>... classes) Construct a Try that contains a single value extracted from the supplied reactive-streams Publisher, will catch any Exceptions of the provided types
T	get()
boolean	isFailure()
default boolean	isPresent()
boolean	isSuccess()
default java.util.Iterator<T>	iterator()
<R> Try<R,X>	map(java.util.function.Function<? super T,? extends R> fn) Transform this functor using the supplied transformation function
default <R> Eval<R>	matches(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> successCase, java.util.function.Function<Matchable.CheckValue1<X,R>,Matchable.CheckValue1<X,R>> failureCase, java.util.function.Supplier<? extends R> otherwise) Pattern match on the value/s inside this Try
default Try<MonadicValue<T>,X>	nest() cojoin pattern.
default Maybe<T>	notNull() Filter elements retaining only values which are not null
static <T,X extends java.lang.Throwable> Try<T,X>	of(T value, java.lang.Class<? extends java.lang.Throwable>... classes) Return a Try that will catch specified exceptions when map / flatMap called For use with liftM / liftM2 and For Comprehensions (when Try is at the top level)
default <U> Maybe<U>	ofType(java.lang.Class<? extends U> type) Keep only those elements in a stream that are of a given type.
Try<T,X>	onFail(java.lang.Class<? extends X> t, java.util.function.Consumer<X> consumer)
Try<T,X>	onFail(java.util.function.Consumer<? super X> consumer)
T	orElse(T value) Get the contained value or else the provided alternative
T	orElseGet(java.util.function.Supplier<? extends T> value) An equivalent operation to Optional.orElseGet(Supplier) Returns a value generated by the provided Supplier if this Convertable is empty or contains a null value.
default <R> Try<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
default Try<T,X>	peek(java.util.function.Consumer<? super T> consumer) Peek at the current value of this Functor, without transforming it
default Try<T,X>	peekFailed(java.util.function.Consumer<? super X> consumer)
Try.Success<T,X>	recover(java.util.function.Function<? super X,? extends T> fn)
Try<T,X>	recoverFor(java.lang.Class<? extends X> t, java.util.function.Function<? super X,? extends T> fn) Recover if exception is of specified type
Try.Success<T,X>	recoverWith(java.util.function.Function<? super X,? extends Try.Success<T,X>> fn) flatMap recovery
Try<T,X>	recoverWithFor(java.lang.Class<? extends X> t, java.util.function.Function<? super X,? extends Try.Success<T,X>> fn) FlatMap recovery function if exception is of specified type
static <X extends java.lang.Throwable> Try<java.lang.Void,X>	runWithCatch(Try.CheckedRunnable<X> cf, java.lang.Class<? extends X>... classes) Try to execute supplied Runnable and will Catch specified Excpetions or java.lang.Exception if none specified.
ReactiveSeq<T>	stream()
static <T,X extends java.lang.Throwable> Try.Success<T,X>	success(T value) Construct a Success instance (an implementation of Try)
void	throwException() Throw exception if Failure, do nothing if success
java.util.Optional<X>	toFailedOptional()
java.util.stream.Stream<X>	toFailedStream()
Ior<X,T>	toIor() Return an Ior that can be this object or a Ior.primary or Ior.secondary
java.util.Optional<T>	toOptional()
default Try<T,java.lang.Throwable>	toTry()
Xor<X,T>	toXor()
default Xor<X,T>	toXorWithError()
default <R> Try<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
default <T> Try<T,X>	unit(T value)
<R> R	visit(java.util.function.Function<? super T,? extends R> success, java.util.function.Function<? super X,? extends R> failure) Execute one function conditional on Try state (Success / Failure)
static <T,X extends java.lang.Throwable> Try<T,X>	withCatch(Try.CheckedSupplier<T,X> cf, java.lang.Class<? extends X>... classes) Try to execute supplied Supplier and will Catch specified Excpetions or java.lang.Exception if none specified.
default <T2,R> Try<R,X>	zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app) Equivalent to ap, but accepts a Publisher and takes the first value only from that publisher.
default <T2,R> Try<R,X>	zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn) Equivalent to ap, but accepts an Iterable and takes the first value only from that iterable.
default <U> Try<org.jooq.lambda.tuple.Tuple2<T,U>,X>	zip(java.lang.Iterable<? extends U> other) Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
default <U> Try<org.jooq.lambda.tuple.Tuple2<T,U>,X>	zip(org.jooq.lambda.Seq<? extends U> other) Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
default <U,R> Try<R,X>	zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper) Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
default <U> Try<org.jooq.lambda.tuple.Tuple2<T,U>,X>	zip(java.util.stream.Stream<? extends U> other) Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
default <U,R> Try<R,X>	zip(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

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

to

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

combineEager, flatMapIterable, flatMapPublisher

Methods inherited from interface com.aol.cyclops.types.stream.ToStream

futureStream, getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream

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, subscribe, test, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFeatureToggle, toFutureStream, toFutureStream, toLazyImmutable, toList, toListX, toMaybe, toMutable, toPBagX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toTry, toTry, 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, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toFutureWAsync, toFutureWAsync, toOptionalAtomicReference, toStream, visit

Methods inherited from interface java.util.function.Predicate

and, isEqual, negate, or

Methods inherited from interface java.lang.Iterable

spliterator

Method Detail

fromPublisher

@SafeVarargs
static <T,X extends java.lang.Throwable> Try<T,X> fromPublisher(org.reactivestreams.Publisher<T> pub,
                                                                             java.lang.Class<X>... classes)

Construct a Try that contains a single value extracted from the supplied reactive-streams Publisher, will catch any Exceptions of the provided types

  
   ReactiveSeq<Integer> stream =  ReactiveSeq.of(1,2,3);
        
        Try<Integer,Throwable> attempt = Try.fromPublisher(stream, RuntimeException.class);
        
        //Try[1]
 
 
 

Parameters:

pub - Publisher to extract value from

Returns:

Try populated with first value from Publisher

fromPublisher

static <T> Try<T,java.lang.Throwable> fromPublisher(org.reactivestreams.Publisher<T> pub)

Construct a Try that contains a single value extracted from the supplied reactive-streams Publisher

  
   ReactiveSeq<Integer> stream =  ReactiveSeq.of(1,2,3);
        
        Try<Integer,Throwable> attempt = Try.fromPublisher(stream);
        
        //Try[1]
 
 
 

Parameters:

pub - Publisher to extract value from

Returns:

Try populated with first value from Publisher

fromIterable

static <T,X extends java.lang.Throwable> Try<T,X> fromIterable(java.lang.Iterable<T> iterable)

Construct a Try that contains a single value extracted from the supplied Iterable

  
   ReactiveSeq<Integer> stream =  ReactiveSeq.of(1,2,3);
        
        Try<Integer,Throwable> attempt = Try.fromIterable(stream);
        
        //Try[1]
 
 
 

Parameters:

iterable - Iterable to extract value from

Returns:

Try populated with first value from Iterable

forEach4

default <T2,R1,R2,R3,R> Try<R,X> forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                          java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                          TriFunction<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                          QuadFunction<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues

  
  Maybe.of(3)
       .forEach4(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->Maybe.none(),
                 (a,b,c,d)->a+b+c+d);
                                  
  
  //Maybe.none
 
 

Specified by:

forEach4 in interface MonadicValue<T>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

value3 - Nested MonadicValue to iterate over

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach4

default <T2,R1,R2,R3,R> Try<R,X> forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                          java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                          TriFunction<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                          QuadFunction<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                          QuadFunction<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues Maybe.of(3) .forEach4(a->Maybe.just(a+10), (a,b)->Maybe.just(a+b), (a,b,c)->Maybe.none(), (a,b,c,d)->a+b+c<100, (a,b,c,d)->a+b+c+d); //Maybe.none

Specified by:

forEach4 in interface MonadicValue<T>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

value3 - Nested MonadicValue to iterate over

filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach3

default <T2,R1,R2,R> Try<R,X> forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                       java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                       TriFunction<? super T,? super R1,? super R2,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues

  
  Maybe.of(3)
       .forEach3(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->a+b+c<100,
                 (a,b,c)->a+b+c);
                                  
  
  //Maybe[32]
 
 

Specified by:

forEach3 in interface MonadicValue<T>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach3

default <T2,R1,R2,R> Try<R,X> forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                       java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                       TriFunction<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                       TriFunction<? super T,? super R1,? super R2,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues

  
  Maybe.of(3)
       .forEach3(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->a+b+c<100,
                 (a,b,c)->a+b+c);
                                  
  
  //Maybe[32]
 
 

Specified by:

forEach3 in interface MonadicValue<T>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach2

default <R1,R> Try<R,X> forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue

  
  Maybe.of(3)
       .forEach2(a->Maybe.none(),
                 (a,b)->a+b);
                                  
 
  //Maybe.none()
 
 

Specified by:

forEach2 in interface MonadicValue<T>

Parameters:

value1 - Nested Monadic Type to iterate over

yieldingFunction - Function with pointers to the current element from both monad types that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach2

default <R1,R> Try<R,X> 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)

Description copied from interface: MonadicValue

Perform a two level nested internal iteration over this MonadicValue and the supplied stream

  
  Maybe.of(3)
       .forEach2(a->Maybe.none(),
                 a->b-> a<3 && b>10,
                 (a,b)->a+b);
                                  
 
  //Maybe.none()
 
 

Specified by:

forEach2 in interface MonadicValue<T>

filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

toTry

default Try<T,java.lang.Throwable> toTry()

Specified by:

toTry in interface Value<T>

Returns:

This Value converted to a Try. If this Value is empty the Try will contain a NoSuchElementException

matches

default <R> Eval<R> matches(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> successCase,
                            java.util.function.Function<Matchable.CheckValue1<X,R>,Matchable.CheckValue1<X,R>> failureCase,
                            java.util.function.Supplier<? extends R> otherwise)

Pattern match on the value/s inside this Try

  
 
 import static com.aol.cyclops.control.Matchable.otherwise;
       import static com.aol.cyclops.control.Matchable.then;
       import static com.aol.cyclops.control.Matchable.when;
       import static com.aol.cyclops.util.function.Predicates.instanceOf;
       
       
   Try.success(10)
      .matches(c->c.is(when(10),then("hello")),
                     c->c.is(when(instanceOf(Throwable.class)), then("error")),
                     otherwise("miss"))
            .get()
            
         //"hello"
 
 
 

Parameters:

successCase - Pattern matching function executed if this Try is a Success

failureCase - Pattern matching function executed if this Try is a Failure

otherwise - Supplier used to provide a value if the selecting pattern matching function fails to find a match

Returns:

Lazy result of the pattern matching

failureGet

X failureGet()

Returns:

The exception returned in the Failure case, Implementations should throw NoSuchElementException if no failure is present

toXor

Xor<X,T> toXor()

Specified by:

toXor in interface Value<T>

Returns:

Primary Xor that has the same value as this Value

toIor

Ior<X,T> toIor()

Description copied from interface: Value

Return an Ior that can be this object or a Ior.primary or Ior.secondary

Specified by:

toIor in interface Value<T>

Returns:

new Ior

coflatMap

default <R> Try<R,X> coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)

Description copied from interface: MonadicValue

Perform a coflatMap operation. The mapping function accepts this MonadicValue and returns a single value to be wrapped inside a Monad.

  
   Maybe.none().coflatMap(m -> m.isPresent() ? m.get() : 10);
   //Maybe[10]
 
 

Specified by:

coflatMap in interface MonadicValue<T>

Parameters:

mapper - Mapping / transformation function

Returns:

MonadicValue wrapping return value from transformation function applied to the value inside this MonadicValue

nest

default Try<MonadicValue<T>,X> nest()

Description copied from interface: MonadicValue

cojoin pattern. Nests this Monad inside another.

Specified by:

nest in interface MonadicValue<T>

Returns:

Nested Monad

combine

default Try<T,X> combine(Monoid<T> monoid,
                         Try<? extends T,X> v2)

Combine this Try with another using the supplied Monoid as a combiner

  
  
  Try<Integer> just = Try.success(10);
  Try<Integer> none = Try.failure(new RuntimeException());
  
  Monoid<Integer> add = Monoid.of(0,Semigroups.intSum);
  
  
        assertThat(just.combine(add,none),equalTo(Try.success(10)));
        assertThat(none.combine(add,just),equalTo(Try.success(0))); 
        assertThat(none.combine(add,none),equalTo(Try.success(0))); 
        assertThat(just.combine(add,Try.success(10)),equalTo(Try.success(20)));
        Monoid<Integer> firstNonNull = Monoid.of(null , Semigroups.firstNonNull());
        assertThat(just.combine(firstNonNull,Try.success(null)),equalTo(just));
        
 
 

Parameters:

monoid - Combiner

v2 - Try to combine with

Returns:

Combined Try

combine

default Combiner<T> combine(java.util.function.BinaryOperator<Combiner<T>> combiner,
                            Combiner<T> app)

Description copied from interface: Combiner

Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout Semigroups 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:

combine in interface Combiner<T>

Returns:

See Also:

Semigroup, Semigroups, Monoid, To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in Semigroups {@see com.aol.cyclops.Semigroups#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops.Monoid) }

 {@code 
 
   
  BinaryOperator> sumMaybes = Semigroups.combineScalarFunctors(Semigroups.intSum);
        Maybe.just(1)
            .combine(sumMaybes, Maybe.just(5))
        //Maybe.just(6));
 }
 

cast

default <U> Try<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 Functor<T>

trampoline

default <R> Try<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 Functor<T>

Parameters:

mapper - TCO Transformation function

Returns:

Functor transformed by the supplied transformation function

ofType

default <U> Maybe<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 Maybe<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 Maybe<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

failure

static <T,X extends java.lang.Throwable> Try.Failure<T,X> failure(X error)

Construct a Failure instance from a throwable (an implementation of Try)

  
    Failure<Exception> failure = Try.failure(new RuntimeException());
 
 

Parameters:

error - for Failure

Returns:

new Failure with error

success

static <T,X extends java.lang.Throwable> Try.Success<T,X> success(T value)

Construct a Success instance (an implementation of Try)

  
    Success<Integer> success = Try.success(new RuntimeException());
 
 

Parameters:

value - Successful value

Returns:

new Success with value

toXorWithError

default Xor<X,T> toXorWithError()

Returns:

Convert this Try to an Xor with the error type as the secondary value

unit

default <T> Try<T,X> unit(T value)

Specified by:

unit in interface MonadicValue<T>

Specified by:

unit in interface Unit<T>

patternMatch

default <R> Try<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 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

visit

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

Execute one function conditional on Try state (Success / Failure)

  
    
     Try<Integer> result = this.execute();
     
     this.logState(result.visit(t->"value is " +t,e->"error is "+e.getMessage());
  
 
 

Parameters:

success - Function to execute if this Try is a Success

failure - Funcion to execute if this Try is a Failure

Returns:

Result of executed function (one or other depending on case)

anyM

AnyMValue<T> anyM()

Specified by:

anyM in interface MonadicValue<T>

Returns:

This monad, wrapped as AnyM of Success

anyMFailure

AnyM<X> anyMFailure()

Returns:

This monad, wrapped as AnyM of Failure

anyMSuccess

AnyM<T> anyMSuccess()

Returns:

This monad, wrapped as AnyM of Success

get

T get()

Specified by:

get in interface Convertable<T>

Specified by:

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

Returns:

Successful value or will throw Throwable (X) if Failire

throwException

void throwException()

Throw exception if Failure, do nothing if success

orElse

T orElse(T value)

Description copied from interface: Convertable

Get the contained value or else the provided alternative

Specified by:

orElse in interface Convertable<T>

Parameters:

value - Return value supplied if Failure, otherwise return Success value

Returns:

Success value or supplied value

orElseGet

T orElseGet(java.util.function.Supplier<? extends T> value)

Description copied from interface: Convertable

An equivalent operation to Optional.orElseGet(Supplier) Returns a value generated by the provided Supplier if this Convertable is empty or contains a null value.

Specified by:

orElseGet in interface Convertable<T>

Parameters:

value - from supplied Supplier if Failure otherwise return Success value

Returns:

Success value

map

<R> Try<R,X> map(java.util.function.Function<? super T,? extends R> fn)

Description copied from interface: Functor

Transform this functor using the supplied transformation function

  
  
  
    of(1,2,3).map(i->i*2)
    
    //[2,4,6]
  
 
 

Specified by:

map in interface ConvertableFunctor<T>

Specified by:

map in interface Functor<T>

Specified by:

map in interface MonadicValue<T>

Parameters:

fn - Map success value from T to R. Do nothing if Failure (return this)

Returns:

New Try with mapped value (Success) or this (Failure)

flatMap

<R> Try<R,X> flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> fn)

Description copied from interface: MonadicValue

A flattening transformation operation (@see Optional.flatMap(Function)

  
   Eval.now(1).map(i->i+2).flatMap(i->Eval.later(()->i*3);
   //Eval[9]
 
 

Specified by:

flatMap in interface MonadicValue<T>

Parameters:

fn - FlatMap success value or Do nothing if Failure (return this)

Returns:

Try returned from FlatMap fn

filter

Maybe<T> filter(java.util.function.Predicate<? super T> p)

Description copied from interface: Filterable

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 Filterable<T>

Specified by:

filter in interface MonadicValue<T>

Parameters:

p - Convert a Success to a Failure (with a null value for Exception) if predicate does not hold. Do nothing to a Failure

Returns:

this if Success and Predicate holds, or if Failure. New Failure if Success and Predicate fails

onFail

Try<T,X> onFail(java.util.function.Consumer<? super X> consumer)

Parameters:

consumer - Accept Exception if present (Failure)

Returns:

this

onFail

Try<T,X> onFail(java.lang.Class<? extends X> t,
                java.util.function.Consumer<X> consumer)

Parameters:

t - Class type of match Exception against

consumer - Accept Exception if present (Failure) and if class types match

Returns:

this

recover

Try.Success<T,X> recover(java.util.function.Function<? super X,? extends T> fn)

Parameters:

fn - Recovery function - map from a failure to a Success.

Returns:

new Success

recoverWith

Try.Success<T,X> recoverWith(java.util.function.Function<? super X,? extends Try.Success<T,X>> fn)

flatMap recovery

Parameters:

fn - Recovery FlatMap function. Map from a failure to a Success

Returns:

Success from recovery function

recoverFor

Try<T,X> recoverFor(java.lang.Class<? extends X> t,
                    java.util.function.Function<? super X,? extends T> fn)

Recover if exception is of specified type

Parameters:

t - Type of exception to match against

fn - Recovery function

Returns:

New Success if failure and types match / otherwise this

recoverWithFor

Try<T,X> recoverWithFor(java.lang.Class<? extends X> t,
                        java.util.function.Function<? super X,? extends Try.Success<T,X>> fn)

FlatMap recovery function if exception is of specified type

Parameters:

t - Type of exception to match against

fn - Recovery FlatMap function. Map from a failure to a Success

Returns:

Success from recovery function or this and types match or if already Success

flatten

Try<T,X> flatten()

Flatten a nested Try Structure

Returns:

Lowest nested Try

toOptional

java.util.Optional<T> toOptional()

Specified by:

toOptional in interface Convertable<T>

Returns:

Optional present if Success, Optional empty if failure

stream

ReactiveSeq<T> stream()

Specified by:

stream in interface Foldable<T>

Specified by:

stream in interface ToStream<T>

Specified by:

stream in interface Value<T>

Returns:

Stream with value if Sucess, Empty Stream if failure

toFailedOptional

java.util.Optional<X> toFailedOptional()

Returns:

Optional present if Failure (with Exception), Optional empty if Success

toFailedStream

java.util.stream.Stream<X> toFailedStream()

Returns:

Stream with error if Failure, Empty Stream if success

isSuccess

boolean isSuccess()

Returns:

true if Success / false if Failure

isFailure

boolean isFailure()

Returns:

True if Failure / false if Success

forEach

void forEach(java.util.function.Consumer<? super T> consumer)

Specified by:

forEach in interface java.lang.Iterable<T>

Parameters:

consumer - Accept value if Success / not called on Failure

forEachFailed

void forEachFailed(java.util.function.Consumer<? super X> consumer)

Parameters:

consumer - Accept value if Failure / not called on Failure

isPresent

default boolean isPresent()

Specified by:

isPresent in interface Convertable<T>

Returns:

True if value exists and is non-null

peek

default Try<T,X> peek(java.util.function.Consumer<? super T> consumer)

Description copied from interface: Functor

Peek at the current value of this Functor, without transforming it

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

Specified by:

peek in interface Functor<T>

Parameters:

consumer - Accept value if Success

Returns:

this

peekFailed

default Try<T,X> peekFailed(java.util.function.Consumer<? super X> consumer)

Parameters:

consumer - Accept Exception if Failure

Returns:

this

iterator

default java.util.Iterator<T> iterator()

Specified by:

iterator in interface Convertable<T>

Specified by:

iterator in interface java.lang.Iterable<T>

Specified by:

iterator in interface ToStream<T>

Specified by:

iterator in interface Value<T>

of

@SafeVarargs
static <T,X extends java.lang.Throwable> Try<T,X> of(T value,
                                                                  java.lang.Class<? extends java.lang.Throwable>... classes)

Return a Try that will catch specified exceptions when map / flatMap called For use with liftM / liftM2 and For Comprehensions (when Try is at the top level)

Parameters:

value - Initial value

classes - Exceptions to catch during map / flatMap

Returns:

Try instance

withCatch

@SafeVarargs
static <T,X extends java.lang.Throwable> Try<T,X> withCatch(Try.CheckedSupplier<T,X> cf,
                                                                         java.lang.Class<? extends X>... classes)

Try to execute supplied Supplier and will Catch specified Excpetions or java.lang.Exception if none specified.

Parameters:

cf - CheckedSupplier to attempt to execute

classes - Exception types to catch (or java.lang.Exception if none specified)

Returns:

New Try

runWithCatch

@SafeVarargs
static <X extends java.lang.Throwable> Try<java.lang.Void,X> runWithCatch(Try.CheckedRunnable<X> cf,
                                                                                       java.lang.Class<? extends X>... classes)

Try to execute supplied Runnable and will Catch specified Excpetions or java.lang.Exception if none specified.

Parameters:

cf - CheckedRunnable to attempt to execute

classes - Exception types to catch (or java.lang.Exception if none specified)

Returns:

New Try

catchExceptions

@SafeVarargs
static <X extends java.lang.Throwable> Try.Init<X> catchExceptions(java.lang.Class<? extends X>... classes)

Fluent step builder for Try / Catch / Finally and Try with resources equivalents. Start with Exception types to catch.

Parameters:

classes - Exception types to catch

Returns:

Next step in the fluent Step Builder

combine

default <T2,R> Try<R,X> combine(Value<? extends T2> app,
                                java.util.function.BiFunction<? super T,? super T2,? extends R> fn)

Description copied from interface: Combiner

Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example

  
   Maybe<Integer> some = Maybe.just(10);
   just.combine(Eval.now(20), this::add);
   //Some[30]
   
   Maybe<Integer> none = Maybe.none();
   none.combine(Eval.now(20), this::add);
   //None
   
 
 

Specified by:

combine in interface Combiner<T>

Parameters:

app - Value to combine with this one.

fn - BiFunction to combine them

Returns:

New Applicativefunctor that represents the combined values

zip

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

Equivalent to ap, but accepts an Iterable and takes the first value only from that iterable.

Specified by:

zip in interface ApplicativeFunctor<T>

Specified by:

zip in interface Zippable<T>

Parameters:

app -

fn -

Returns:

zip

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

Equivalent to ap, but accepts a Publisher and takes the first value only from that publisher.

Specified by:

zip in interface ApplicativeFunctor<T>

Specified by:

zip in interface Zippable<T>

Parameters:

app -

fn -

Returns:

zip

default <U,R> Try<R,X> zip(org.jooq.lambda.Seq<? 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 Seq, using the supplied combining function

Specified by:

zip in interface Zippable<T>

Parameters:

other - Seq to combine with

zipper - Zip / combining function

Returns:

Combined zippable

zip

default <U,R> Try<R,X> zip(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:

zip in interface Zippable<T>

Parameters:

other - Stream to combine with

zipper - Zip / combining function

Returns:

Combined zippable

zip

default <U> Try<org.jooq.lambda.tuple.Tuple2<T,U>,X> zip(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:

zip in interface Zippable<T>

Parameters:

other - Stream to combine with

Returns:

Combined Zippable

zip

default <U> Try<org.jooq.lambda.tuple.Tuple2<T,U>,X> zip(org.jooq.lambda.Seq<? extends U> other)

Description copied from interface: Zippable

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

Specified by:

zip in interface Zippable<T>

Parameters:

other - Seq to combine with

Returns:

Combined Zippable

zip

default <U> Try<org.jooq.lambda.tuple.Tuple2<T,U>,X> 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: