cyclops.control

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

java.lang.Object

cyclops.control.Try<T,X>

Type Parameters:

T - Return type (success)

X - Base Error type

All Implemented Interfaces:

Convert<Higher<Higher<Witness.tryType,X>,T>>, Higher<Higher<Witness.tryType,X>,T>, Higher2<Witness.tryType,X,T>, Unit<T>, Filters<T>, Convertable<T>, Folds<T>, To<Try<T,X>>, Visitable<T>, Transformable<T>, MonadicValue<T>, Recoverable<T>, RecoverableFrom<X,T>, Value<T>, Zippable<T>, Fn0<T>, java.lang.Iterable<T>, java.util.function.Predicate<T>, java.util.function.Supplier<T>, org.reactivestreams.Publisher<T>

public class Try<T,X extends java.lang.Throwable>
extends java.lang.Object
implements To<Try<T,X>>, RecoverableFrom<X,T>, MonadicValue<T>, Higher2<Witness.tryType,X,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 Support eager, lazy and reactiveBuffer execution modes 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("public");

  //"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->"public);

 
 

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

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

//Failure[RuntimeException]

 
 

Nested Class Summary

Nested Classes

Modifier and Type	Class 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 interface	Try.Init<X extends java.lang.Throwable>
static class	Try.Instances
static class	Try.MyFinallyBlock<T,V,X extends java.lang.Throwable>
static interface	Try.TryCatch<V,X extends java.lang.Throwable>

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

Value.ValueImpl<T>

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

Convertable.SupplierToConvertable<T>

Nested classes/interfaces inherited from interface cyclops.function.Fn0

Fn0.FunctionalOperations<R>, Fn0.SupplierKind<R>

Constructor Summary

Constructors

Constructor and Description
Try()

Method Summary

Modifier and Type	Method and Description
static <ST extends java.lang.Throwable,PT,R> Xor<?,R>	accumulateFailures(CollectionX<Try<PT,ST>> xors, java.util.function.Function<? super ST,R> mapper, Monoid<R> reducer) Accumulate the results only from those Trys which have a Secondary type present, using the supplied mapping function to convert the data from each Try before reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids ..
static <ST extends java.lang.Throwable,PT,R> Xor<?,R>	accumulateFailures(CollectionX<Try<PT,ST>> xors, Reducer<R> reducer) Accumulate the result of the Secondary types in the Collection of Trys provided using the supplied Reducer cyclops2.Reducers.
static <ST extends java.lang.Throwable,PT> Xor<?,ST>	accumulateFailures(Monoid<ST> reducer, CollectionX<Try<PT,ST>> xors) Accumulate the results only from those Trys which have a Secondary type present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids .
static <ST extends java.lang.Throwable,PT,R> Xor<?,R>	accumulateSuccesses(CollectionX<Try<PT,ST>> xors, java.util.function.Function<? super PT,R> mapper, Monoid<R> reducer) \ Accumulate the results only from those Iors which have a Primary type present, using the supplied mapping function to convert the data from each Try before reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids ..
static <ST extends java.lang.Throwable,PT,R> Xor<?,R>	accumulateSuccesses(CollectionX<Try<PT,ST>> xors, Reducer<R> reducer) Accumulate the result of the Primary types in the Collection of Trys provided using the supplied Reducer cyclops2.Reducers.
static <ST extends java.lang.Throwable,PT> Xor<?,PT>	accumulateSuccesses(Monoid<PT> reducer, CollectionX<Try<PT,ST>> xors) Accumulate the results only from those Trys which have a Primary type present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids .
Active<Higher<Witness.tryType,X>,T>	allTypeclasses()
AnyMValue2<Witness.tryType,X,T>	anyM()
int	arity()
Xor<X,T>	asXor()
<U> Try<U,X>	cast(java.lang.Class<? extends U> type) Cast all elements in a reactiveStream 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.
<R> Try<R,X>	coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper) Perform a coflatMap operation.
Try<T,X>	combine(Monoid<T> monoid, Try<? extends T,X> v2) Combine this Try with another using the supplied Monoid as a combiner
<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
Try<T,X>	combineEager(Monoid<T> monoid, MonadicValue<? extends T> v2) Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e.
<W1> Coproduct<W1,Higher<Witness.tryType,X>,T>	coproduct(InstanceDefinitions<W1> def2)
boolean	equals(java.lang.Object o)
static <T,X extends java.lang.Throwable> Try<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.
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)
<R> Try<R,X>	flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper) A flattening transformation operation that takes the first value from the returned Iterable.
<R> Try<R,X>	flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) A flattening transformation operation that takes the first value from the returned Publisher.
<R> Try<R,X>	flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> mapper)
static <T,X extends java.lang.Throwable> Try<T,X>	flatten(Try<? extends Try<T,X>,X> nested)
void	forEach(java.util.function.Consumer<? super T> consumer)
<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
<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 reactiveStream
<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, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction) Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
<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, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction) Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
<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, Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? 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
<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, Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? 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 singleUnsafe 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 singleUnsafe value extracted from the supplied reactiveBuffer-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 singleUnsafe value extracted from the supplied reactiveBuffer-streams Publisher, will catch any Exceptions of the provided types
static <T,X extends java.lang.Throwable> Try<T,X>	fromXor(Xor<X,T> pub)
T	get()
int	hashCode()
boolean	isFailure()
boolean	isPresent()
boolean	isSuccess()
java.util.Iterator<T>	iterator()
static <X extends java.lang.Throwable,T> Cokleisli<Higher<Witness.tryType,X>,T,Try<T,X>>	kindCokleisli()
static <X extends java.lang.Throwable,T> Kleisli<Higher<Witness.tryType,X>,Try<T,X>,T>	kindKleisli()
<R> Try<R,X>	map(java.util.function.Function<? super T,? extends R> fn) Transform this functor using the supplied transformation function
<W2,R> Nested<Higher<Witness.tryType,X>,W2,R>	mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs)
java.lang.String	mkString() Returns the class name and the name of the subclass, if there is any value, the value is showed between square brackets.
static <T,X extends java.lang.Throwable> Try<T,X>	narrowK(Higher<Higher<Witness.tryType,X>,T> t)
static <T,X extends java.lang.Throwable> Try<T,X>	narrowK2(Higher2<Witness.tryType,X,T> t)
Try<MonadicValue<T>,X>	nest() cojoin pattern.
static <W1,X extends java.lang.Throwable,T> Nested<Higher<Witness.tryType,X>,W1,T>	nested(Try<Higher<W1,T>,X> nested, InstanceDefinitions<W1> def2)
Maybe<T>	notNull() Filter elements retaining only values which are not null
<U> Maybe<U>	ofType(java.lang.Class<? extends U> type) Keep only those elements in a reactiveStream 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 zero or contains a null value.
Try<T,X>	peek(java.util.function.Consumer<? super T> consumer) Peek at the current value of this Transformable, without transforming it
Try<T,X>	peekFailed(java.util.function.Consumer<? super X> consumer)
<W1> Product<Higher<Witness.tryType,X>,W1,T>	product(Active<W1,T> active)
Try<T,X>	recover(java.util.function.Function<? super X,? extends T> fn)
Try<T,X>	recover(java.util.function.Supplier<? extends T> s)
Try<T,X>	recoverFlatMap(java.util.function.Function<? super X,? extends Try<T,X>> fn) flatMap recovery
Try<T,X>	recoverFlatMapFor(java.lang.Class<? extends X> t, java.util.function.Function<? super X,? extends Try<T,X>> 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
<R> Try<R,X>	retry(java.util.function.Function<? super T,? extends R> fn) Retry a transformation if it fails.
<R> Try<R,X>	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 <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.
static <ST extends java.lang.Throwable,PT> Xor<ListX<PT>,ListX<ST>>	sequenceFailures(CollectionX<Try<PT,ST>> xors) Turn a list of Trys into a single Try with Lists of values.
static <ST extends java.lang.Throwable,PT> Xor<ListX<ST>,ListX<PT>>	sequenceSuccess(CollectionX<Try<PT,ST>> xors) Turn a toX of Trys into a single Ior with Lists of values.
ReactiveSeq<T>	stream()
void	subscribe(org.reactivestreams.Subscriber<? super T> sub)
static <T,X extends java.lang.Throwable> Try<T,X>	success(T value) Construct a Success instance (an implementation of Try)
static <T,X extends java.lang.Throwable> Try<T,X>	success(T value, java.lang.Class<? extends java.lang.Throwable>... classes)
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()
java.lang.String	toString()
Trampoline<Xor<X,T>>	toTrampoline()
Try<T,java.lang.Throwable>	toTry()
Xor<X,T>	toXor()
Xor<X,T>	toXorWithError()
<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
<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 <X extends java.lang.Throwable,T> Higher<Higher<Witness.tryType,X>,T>	widen(Try<T,X> narrow)
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.
Try<T,X>	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> 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.
<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
<S,U> Try<org.jooq.lambda.tuple.Tuple3<T,S,U>,X>	zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third) zip 3 Streams into one
<S,U,R> Try<R,X>	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> Try<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>,X>	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> Try<R,X>	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> Try<R,X>	zipP(org.reactivestreams.Publisher<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn) Equivalent to ap, but accepts a Publisher and takes the first value only from that publisher.
<U> Try<org.jooq.lambda.tuple.Tuple2<T,U>,X>	zipP(org.reactivestreams.Publisher<? extends U> other)
<U> Try<org.jooq.lambda.tuple.Tuple2<T,U>,X>	zipS(java.util.stream.Stream<? extends U> other) Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
<U,R> Try<R,X>	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> Try<R,X>	zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)
<R> Try<R,X>	zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)
<R> Try<R,X>	zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

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

to

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

apply, generate, iterate, newSubscriber, of, test, toEither, toEval, toEvalAlways, toEvalLater, toEvalNow, toLeft, toMaybe, toMaybeEager, toRight, toTry, toTry, toXor

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

collect, fromSupplier, orElseThrow, toCompletableFuture, toCompletableFutureAsync, toFuture, toFutureAsync, toStream, visit

Methods inherited from interface java.lang.Iterable

spliterator

Methods inherited from interface cyclops.function.Fn0

andThen, fnTo, functionOps, future, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, memoizeAsync, memoizeAsync, run, suspend, λ, λv

Methods inherited from interface java.util.function.Predicate

and, isEqual, negate, or

Methods inherited from interface com.aol.cyclops2.hkt.Higher

applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.aol.cyclops2.hkt.Convert

convert

Constructor Detail

Try

public Try()

Method Detail

asXor

public Xor<X,T> asXor()

kindKleisli

public static <X extends java.lang.Throwable,T> Kleisli<Higher<Witness.tryType,X>,Try<T,X>,T> kindKleisli()

widen

public static <X extends java.lang.Throwable,T> Higher<Higher<Witness.tryType,X>,T> widen(Try<T,X> narrow)

kindCokleisli

public static <X extends java.lang.Throwable,T> Cokleisli<Higher<Witness.tryType,X>,T,Try<T,X>> kindCokleisli()

allTypeclasses

public Active<Higher<Witness.tryType,X>,T> allTypeclasses()

mapM

public <W2,R> Nested<Higher<Witness.tryType,X>,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn,
                                                          InstanceDefinitions<W2> defs)

toTrampoline

public Trampoline<Xor<X,T>> toTrampoline()

subscribe

public void subscribe(org.reactivestreams.Subscriber<? super T> sub)

Specified by:

subscribe in interface Value<T>

Specified by:

subscribe in interface org.reactivestreams.Publisher<T>

sequenceFailures

public static <ST extends java.lang.Throwable,PT> Xor<ListX<PT>,ListX<ST>> sequenceFailures(CollectionX<Try<PT,ST>> xors)

Turn a list of Trys into a single Try with Lists of values. Primary and failure types are swapped during this operation.

 
  Try<Integer,NoSuchElementException> just  = Try.success(10);
    Try<Integer,NoSuchElementException> none = Try.failure(new NoSuchElementException());

  Xor<ListX<Integer>,ListX<NoSuchElementException>> xors =Try.sequenceFailures(ListX.of(just,none,Try.success(1)));
    //[Primary[NoSuchElementException]]

 
 

Parameters:

xors - Trys to sequence

Returns:

Try sequenced and swapped

accumulateFailures

public static <ST extends java.lang.Throwable,PT,R> Xor<?,R> accumulateFailures(CollectionX<Try<PT,ST>> xors,
                                                                                Reducer<R> reducer)

Accumulate the result of the Secondary types in the Collection of Trys provided using the supplied Reducer cyclops2.Reducers.

 
  Try<Integer,NoSuchElementException>  just  = Try.success(10);
    Try<Integer,NoSuchElementException> none = Try.failure(new NoSuchElementException());

  Xor<?,PersistentSetX<String>> xors = Try.accumulateFailures(ListX.of(just,none,Try.success(1)),Reducers.<String>toPersistentSetX());
    //Primary[PersistentSetX[NoSuchElementException]]]
 
 

Parameters:

xors - Collection of Iors to accumulate failure values

reducer - Reducer to accumulate results

Returns:

Try populated with the accumulate failure operation

accumulateFailures

public static <ST extends java.lang.Throwable,PT,R> Xor<?,R> accumulateFailures(CollectionX<Try<PT,ST>> xors,
                                                                                java.util.function.Function<? super ST,R> mapper,
                                                                                Monoid<R> reducer)

Accumulate the results only from those Trys which have a Secondary type present, using the supplied mapping function to convert the data from each Try before reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids ..

 
  Try<Integer,NoSuchElementException> just  = Try.success(10);
    Try<Integer,NoSuchElementException> none = Try.failure(new NoSuchElementException());

   Xor<?,String> xors = Try.accumulateFailures(ListX.of(just,none,Try.failure("1")),i->""+i,Monoids.stringConcat);
    //Primary[NoSuchElementException]]

 
 

Parameters:

xors - Collection of Iors to accumulate failure values

mapper - Mapping function to be applied to the result of each Ior

reducer - Semigroup to combine values from each Ior

Returns:

Try populated with the accumulate Secondary operation

sequenceSuccess

public static <ST extends java.lang.Throwable,PT> Xor<ListX<ST>,ListX<PT>> sequenceSuccess(CollectionX<Try<PT,ST>> xors)

Turn a toX of Trys into a single Ior with Lists of values.

 

 Try<Integer,NoSuchElementException> just  = Try.success(10);
    Try<Integer,NoSuchElementException> none = Try.failure(new NoSuchElementException());


 Xor<ListX<String>,ListX<Integer>> xors =Try.sequenceSuccess(ListX.of(just,none,Try.success(1)));
    //Primary(ListX.of(10,1)));

 

Parameters:

iors - Trys to sequence

Returns:

Try Sequenced

accumulateSuccesses

public static <ST extends java.lang.Throwable,PT,R> Xor<?,R> accumulateSuccesses(CollectionX<Try<PT,ST>> xors,
                                                                                 Reducer<R> reducer)

Accumulate the result of the Primary types in the Collection of Trys provided using the supplied Reducer cyclops2.Reducers.

 
  Try<Integer,NoSuchElementException> just  = Try.success(10);
    Try<Integer,NoSuchElementException> none = Try.failure(new NoSuchElementException());

  Try<PersistentSetX<Integer>,Throwable> xors =Try.accumulateSuccesses(ListX.of(just,none,Try.success(1)),Reducers.toPersistentSetX());
    //Primary[PersistentSetX[10,1]]
 
 

Parameters:

Trys - Collection of Iors to accumulate success values

reducer - Reducer to accumulate results

Returns:

Try populated with the accumulate success operation

accumulateSuccesses

public static <ST extends java.lang.Throwable,PT,R> Xor<?,R> accumulateSuccesses(CollectionX<Try<PT,ST>> xors,
                                                                                 java.util.function.Function<? super PT,R> mapper,
                                                                                 Monoid<R> reducer)

\ Accumulate the results only from those Iors which have a Primary type present, using the supplied mapping function to convert the data from each Try before reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids ..

 
  Try<Integer,NoSuchElementException> just  = Try.success(10);
    Try<Integer,NoSuchElementException> none = Try.failure(new NoSuchElementException());

  Xor<?,String> iors = Try.accumulateSuccesses(ListX.of(just,none,Try.success(1)),i->""+i,Monoids.stringConcat);
    //Primary["101"]
 
 

Parameters:

xors - Collection of Iors to accumulate success values

mapper - Mapping function to be applied to the result of each Ior

reducer - Reducer to accumulate results

Returns:

Try populated with the accumulate success operation

accumulateSuccesses

public static <ST extends java.lang.Throwable,PT> Xor<?,PT> accumulateSuccesses(Monoid<PT> reducer,
                                                                                CollectionX<Try<PT,ST>> xors)

Accumulate the results only from those Trys which have a Primary type present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids .

 
  Try<Integer,NoSuchElementException> just  = Try.success(10);
    Try<Integer,NoSuchElementException> none = Try.failure(new NoSuchElementException());

  Try<?,Integer> xors = Try.accumulateSuccesses(Monoids.intSum,ListX.of(just,none,Try.success(1)));
    //Primary[11]

 
 

Parameters:

xors - Collection of Trys to accumulate success values

reducer - Reducer to accumulate results

Returns:

Try populated with the accumulate success operation

accumulateFailures

public static <ST extends java.lang.Throwable,PT> Xor<?,ST> accumulateFailures(Monoid<ST> reducer,
                                                                               CollectionX<Try<PT,ST>> xors)

Accumulate the results only from those Trys which have a Secondary type present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids .

 
 Try.accumulateFailures(ListX.of(Try.failure(new NoSuchElementException());,
 Try.failure(new NoSuchElementException());
    Try.success("success")),SemigroupK.stringConcat)

 //Primary[NoSuchElementException, NoSuchElementException]
 
 

Parameters:

xors - Collection of Trys to accumulate failure values

reducer - Semigroup to combine values from each Try

Returns:

Try populated with the accumulate Secondary operation

recover

public Try<T,X> recover(java.util.function.Supplier<? extends T> s)

Specified by:

recover in interface Recoverable<T>

fromXor

public static <T,X extends java.lang.Throwable> Try<T,X> fromXor(Xor<X,T> pub)

fromPublisher

@SafeVarargs
public 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 singleUnsafe value extracted from the supplied reactiveBuffer-streams Publisher, will catch any Exceptions of the provided types

 
   ReactiveSeq<Integer> reactiveStream =  ReactiveSeq.of(1,2,3);

    Try<Integer,Throwable> recover = Try.fromPublisher(reactiveStream, RuntimeException.class);

    //Try[1]

 
 

Parameters:

pub - Publisher to extract value from

Returns:

Try populated with first value from Publisher

fromPublisher

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

Construct a Try that contains a singleUnsafe value extracted from the supplied reactiveBuffer-streams Publisher

 
   ReactiveSeq<Integer> reactiveStream =  ReactiveSeq.of(1,2,3);

    Try<Integer,Throwable> recover = Try.fromPublisher(reactiveStream);

    //Try[1]

 
 

Parameters:

pub - Publisher to extract value from

Returns:

Try populated with first value from Publisher

fromIterable

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

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

 
   ReactiveSeq<Integer> reactiveStream =  ReactiveSeq.of(1,2,3);

    Try<Integer,Throwable> recover = Try.fromIterable(reactiveStream);

    //Try[1]

 
 

Parameters:

iterable - Iterable to extract value from

Returns:

Try populated with first value from Iterable

zipWith

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

Specified by:

zipWith in interface Zippable<T>

zipWithS

public <R> Try<R,X> zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)

Specified by:

zipWithS in interface Zippable<T>

zipWithP

public <R> Try<R,X> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)

Specified by:

zipWithP in interface Zippable<T>

retry

public <R> Try<R,X> 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

zipP

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

Specified by:

zipP in interface Zippable<T>

retry

public <R> Try<R,X> 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

zip3

public <S,U> Try<org.jooq.lambda.tuple.Tuple3<T,S,U>,X> 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> Try<R,X> 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> Try<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>,X> 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> Try<R,X> 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>

flatMapS

public <R> Try<R,X> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> mapper)

Specified by:

flatMapS in interface MonadicValue<T>

combineEager

public Try<T,X> combineEager(Monoid<T> monoid,
                             MonadicValue<? extends T> v2)

Description copied from interface: MonadicValue

Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e. maybe / async alternatives)

  
 
  Monoid<Integer> add = Monoid.of(1,SemigroupK.intSum);
  Maybe.of(10).combineEager(add,Maybe.none());
  //Maybe[10]
  
  Maybe.none().combineEager(add,Maybe.of(10));
  //Maybe[10]
  
  Maybe.none().combineEager(add,Maybe.none());
  //Maybe.none()
  
  Maybe.of(10).combineEager(add,Maybe.of(10));
  //Maybe[20]
  
  Monoid<Integer> firstNonNull = Monoid.of(null , SemigroupK.firstNonNull());
  Maybe.of(10).combineEager(firstNonNull,Maybe.of(10));
  //Maybe[10]
 

Specified by:

combineEager in interface MonadicValue<T>

Returns:

flatMapI

public <R> Try<R,X> flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)

Description copied from interface: MonadicValue

A flattening transformation operation that takes the first value from the returned Iterable.

  
   Maybe.just(1).map(i->i+2).flatMapI(i->Arrays.asList(()->i*3,20);
   //Maybe[9]
 
 

Specified by:

flatMapI in interface MonadicValue<T>

Parameters:

mapper - transformation function

Returns:

MonadicValue

flatMapP

public <R> Try<R,X> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

Description copied from interface: MonadicValue

A flattening transformation operation that takes the first value from the returned Publisher.

  
   Future.ofResult(1).map(i->i+2).flatMapP(i->Flux.just(()->i*3,20);
   //Future[9]
 
 

Specified by:

flatMapP in interface MonadicValue<T>

Parameters:

mapper - transformation function

Returns:

MonadicValue

forEach4

public <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,
                                         Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                         Fn4<? 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

public <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,
                                         Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                         Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                         Fn4<? 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 applyHKT 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

public <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,
                                      Fn3<? 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

public <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,
                                      Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                      Fn3<? 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 applyHKT 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

public <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

public <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 reactiveStream

  
  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 applyHKT 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

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

Specified by:

toTry in interface Value<T>

Returns:

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

failureGet

public X failureGet()

Returns:

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

toXor

public Xor<X,T> toXor()

Specified by:

toXor in interface Value<T>

Returns:

Primary Xor that has the same value as this Value

toIor

public 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

public <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 singleUnsafe 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

public 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

public 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,SemigroupK.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 , SemigroupK.firstNonNull());
    assertThat(just.combine(firstNonNull,Try.success(null)),equalTo(just));

 
 

Parameters:

monoid - Combiner

v2 - Try to combine with

Returns:

Combined Try

zip

public Try<T,X> 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));
 }
 

cast

public <U> Try<U,X> 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>

trampoline

public <R> Try<R,X> 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

ofType

public <U> Maybe<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 Maybe<T> filterNot(java.util.function.Predicate<? super T> fn)

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:

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

notNull

public Maybe<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

failure

public static <T,X extends java.lang.Throwable> Try<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

public static <T,X extends java.lang.Throwable> Try<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

success

public static <T,X extends java.lang.Throwable> Try<T,X> success(T value,
                                                                 java.lang.Class<? extends java.lang.Throwable>... classes)

toXorWithError

public Xor<X,T> toXorWithError()

Returns:

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

unit

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

Specified by:

unit in interface Unit<T>

Specified by:

unit in interface MonadicValue<T>

visit

public <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

public AnyMValue2<Witness.tryType,X,T> anyM()

Returns:

This monad, wrapped as AnyM of Success

get

public 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

public void throwException()

Throw exception if Failure, do nothing if success

orElse

public 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

public 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 zero 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

public <R> Try<R,X> 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>

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

public <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

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

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>

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

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

Parameters:

consumer - Accept Exception if present (Failure)

Returns:

this

onFail

public 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

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

Specified by:

recover in interface RecoverableFrom<X extends java.lang.Throwable,T>

Parameters:

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

Returns:

new Try

recoverFlatMap

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

flatMap recovery

Parameters:

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

Returns:

Success from recovery function

recoverFlatMapFor

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

recoverFor

public 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

toOptional

public java.util.Optional<T> toOptional()

Specified by:

toOptional in interface Convertable<T>

Returns:

Optional present if Success, Optional zero if failure

stream

public ReactiveSeq<T> stream()

Specified by:

stream in interface Folds<T>

Specified by:

stream in interface Value<T>

Returns:

Stream with value if Sucess, Empty Stream if failure

toFailedOptional

public java.util.Optional<X> toFailedOptional()

Returns:

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

toFailedStream

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

Returns:

Stream with error if Failure, Empty Stream if success

isSuccess

public boolean isSuccess()

Returns:

true if Success / false if Failure

isFailure

public boolean isFailure()

Returns:

True if Failure / false if Success

forEach

public 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

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

Parameters:

consumer - Accept value if Failure / not called on Failure

isPresent

public boolean isPresent()

Specified by:

isPresent in interface Convertable<T>

Returns:

True if value exists and is non-null

peek

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

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:

consumer - Accept value if Success

Returns:

this

peekFailed

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

Parameters:

consumer - Accept Exception if Failure

Returns:

this

iterator

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

Specified by:

iterator in interface Convertable<T>

Specified by:

iterator in interface Value<T>

Specified by:

iterator in interface java.lang.Iterable<T>

withCatch

@SafeVarargs
public 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 recover to execute

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

Returns:

New Try

runWithCatch

@SafeVarargs
public 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 recover to execute

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

Returns:

New Try

catchExceptions

@SafeVarargs
public 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

flatten

public static <T,X extends java.lang.Throwable> Try<T,X> flatten(Try<? extends Try<T,X>,X> nested)

combine

public <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: MonadicValue

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

Parameters:

app - Value to combine with this one.

fn - BiFunction to combine them

Returns:

New Applicativefunctor that represents the combined values

zip

public <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 MonadicValue<T>

Specified by:

zip in interface Zippable<T>

Parameters:

app -

fn -

Returns:

zipP

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

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

Specified by:

zipP in interface MonadicValue<T>

Specified by:

zipP in interface Zippable<T>

Parameters:

app -

fn -

Returns:

zipS

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

zip

public <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:

mkString

public java.lang.String mkString()

Description copied from interface: Value

Returns the class name and the name of the subclass, if there is any value, the value is showed between square brackets.

Specified by:

mkString in interface Value<T>

Returns:

String

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

equals

public boolean equals(java.lang.Object o)

Overrides:

equals in class java.lang.Object

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

arity

public int arity()

Specified by:

arity in interface MonadicValue<T>

narrowK2

public static <T,X extends java.lang.Throwable> Try<T,X> narrowK2(Higher2<Witness.tryType,X,T> t)

narrowK

public static <T,X extends java.lang.Throwable> Try<T,X> narrowK(Higher<Higher<Witness.tryType,X>,T> t)

nested

public static <W1,X extends java.lang.Throwable,T> Nested<Higher<Witness.tryType,X>,W1,T> nested(Try<Higher<W1,T>,X> nested,
                                                                                                 InstanceDefinitions<W1> def2)

product

public <W1> Product<Higher<Witness.tryType,X>,W1,T> product(Active<W1,T> active)

coproduct

public <W1> Coproduct<W1,Higher<Witness.tryType,X>,T> coproduct(InstanceDefinitions<W1> def2)