cyclops.typeclasses

Class Active<W,T>

java.lang.Object

cyclops.typeclasses.Active<W,T>

Type Parameters:

W - Witness type

T - Data type

All Implemented Interfaces:

Filters<T>, To<Active<W,T>>, Transformable<T>

public class Active<W,T>
extends java.lang.Object
implements Filters<T>, Transformable<T>, To<Active<W,T>>

Provide easy access to all typeclasses for a type e.g.

     
       Active<list,Integer> active = Active.of(ListX.of(1,2,3),ListX.Instances.definitions());
       Active<list,Integer> doubled = active.map(i->i*2);
       Active<list,Integer> doubledPlusOne = doubled.flatMap(i->ListX.of(i+1));
     

 

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	Active.Converter<S>
class	Active.Plus
class	Active.Unfolds

Constructor Summary

Constructors

Constructor and Description
Active()

Method Summary

Modifier and Type	Method and Description
boolean	allMatch(java.util.function.Predicate<? super T> pred)
boolean	anyMatch(java.util.function.Predicate<? super T> pred)
<C,R> Active<W,R>	ap(C c, java.util.function.Function<? super C,? extends Higher<W,? extends java.util.function.Function<T,R>>> fn)
<R> Active<W,R>	ap(Higher<W,? extends java.util.function.Function<T,R>> fn)
<U> Active<W,U>	cast(java.lang.Class<? extends U> type) Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException.
<W2> Product<W,W2,T>	concat(Active<W2,T> active)
<C,R> cyclops.typeclasses.Active.NarrowedApplicative<C,R>	concreteAp(Kleisli<W,C,java.util.function.Function<T,R>> widen)
<S,R> Active.Converter<S>	concreteConversion(java.util.function.Function<? super Higher<W,T>,? extends S> narrow) Convert this Active to a new type via the underlying concrete type e.g.
<C,R> cyclops.typeclasses.Active.NarrowedFlatMap<C,R>	concreteFlatMap(Kleisli<W,C,R> widen) Use concreteFlatMap to access a flatMap operator that works with the concrete type (rather than the higher kind encoding) e.g.
<C> cyclops.typeclasses.Active.Narrowed<C>	concreteMonoid(Kleisli<W,C,T> widen, Cokleisli<W,T,C> narrow)
<C,R> cyclops.typeclasses.Active.NarrowedTailRec<C,R>	concreteTailRec(Kleisli<W,C,Xor<T,R>> widen)
<S,R> Active<W,R>	custom(java.util.function.Function<? super Higher<W,T>,? extends S> narrow, java.util.function.Function<? super S,? extends Higher<W,R>> fn) Perform a custom operation
Active<W,T>	filter(java.util.function.Predicate<? super T> predicate) Keep only elements for which the supplied predicates hold e.g.
Active<W,T>	filterNot(java.util.function.Predicate<? super T> predicate) Remove any elements for which the predicate holds (inverse operation to filter) e.g.
<R> Active<W,R>	flatMap(java.util.function.Function<? super T,? extends Higher<W,R>> fn)
<R> Active<W,R>	flatMapA(java.util.function.Function<? super T,? extends Active<W,R>> fn)
<C2,T> Higher<C2,Active<W,T>>	flatSequenceA(Applicative<C2> applicative, Active<W,Higher<C2,Active<W,T>>> fgfa)
<W2,R> Higher<W2,Higher<W,R>>	flatTraverse(Applicative<W2> applicative, java.util.function.Function<? super T,? extends Higher<W2,Higher<W,R>>> f)
<C2,R> Higher<C2,Active<W,R>>	flatTraverseA(Applicative<C2> applicative, java.util.function.Function<? super T,? extends Higher<C2,Active<W,R>>> f)
T	foldLeft(Monoid<T> monoid)
T	foldLeft(T identity, java.util.function.BinaryOperator<T> semigroup)
<R> R	foldMap(Monoid<R> mb, java.util.function.Function<? super T,? extends R> fn)
T	foldRight(Monoid<T> monoid)
T	foldRight(T identity, java.util.function.BinaryOperator<T> semigroup)
<R1,R> Active<W,R>	forEach2(java.util.function.Function<? super T,? extends Higher<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
<R1,R> Maybe<Active<W,R>>	forEach2(java.util.function.Function<? super T,? extends Higher<W,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)
<T2,R1,R2,R> Active<W,R>	forEach3(java.util.function.Function<? super T,? extends Higher<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends Higher<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
<T2,R1,R2,R> Maybe<Active<W,R>>	forEach3(java.util.function.Function<? super T,? extends Higher<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends Higher<W,R2>> value2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
<T2,R1,R2,R3,R> Active<W,R>	forEach4(java.util.function.Function<? super T,? extends Higher<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends Higher<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends Higher<W,R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
<T2,R1,R2,R3,R> Maybe<Active<W,R>>	forEach4(java.util.function.Function<? super T,? extends Higher<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends Higher<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends Higher<W,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)
Higher<W,T>	getActive()
T	getAt(int index)
T	intercalate(Monoid<T> monoid, T value)
<T2,R> Eval<Active<W,R>>	lazyZip(Eval<Higher<W,T2>> lazy, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
<T2,R> Eval<Active<W,R>>	lazyZipA(Eval<Active<W,T2>> lazy, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
<R> java.util.function.Function<Active<W,T>,Active<W,R>>	lift(java.util.function.Function<? super T,? extends R> fn)
<R> Active<W,R>	map(java.util.function.Function<? super T,? extends R> fn) Transform this functor using the supplied transformation function
<W2> Active<W2,T>	mapK(FunctionK<W,W2,T> fn)
<R> Active<W,R>	mapWithIndex(java.util.function.BiFunction<? super T,java.lang.Long,? extends R> f)
Active<W,T>	notNull() Filter elements retaining only values which are not null
static <C,W,T> Active<W,T>	of(java.util.function.Function<? super C,? extends Higher<W,T>> single, C c, InstanceDefinitions<W> def1)
static <W,T> Active<W,T>	of(Higher<W,T> single, InstanceDefinitions<W> def1)
static <W,T> Active<W,T>	of(InstanceDefinitions<W> def1, T value)
<U> Active<W,U>	ofType(java.lang.Class<? extends U> type) Keep only those elements in a reactiveStream that are of a given type.
Active<W,T>	peek(java.util.function.Consumer<? super T> fn) Peek at the current value of this Transformable, without transforming it
Maybe<Active.Plus>	plus()
Active.Plus	plus(MonadPlus<W> plus)
Active<W,T>	plus(SemigroupK<W,T> semigroupK, Active<W,T> add)
Active<W,T>	plus(SemigroupK<W,T> semigroupK, Higher<W,T> add)
Active.Plus	plusUnsafe() Deprecated.
<R> Active<W,R>	retry(java.util.function.Function<? super T,? extends R> fn) Retry a transformation if it fails.
<R> Active<W,R>	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.
Active<W,T>	reverse()
<C2,T> Higher<C2,Active<W,T>>	sequenceA(Applicative<C2> applicative, Active<W,Higher<C2,T>> ds)
java.lang.String	show()
long	size()
ReactiveSeq<T>	stream()
<R> Active<W,R>	tailRec(T initial, java.util.function.Function<? super T,? extends Higher<W,? extends Xor<T,R>>> fn)
<R> Active<W,R>	tailRecA(T initial, java.util.function.Function<? super T,? extends Active<W,? extends Xor<T,R>>> fn)
ListX<T>	toListX()
java.lang.String	toString()
<R> Active<W,R>	trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper) Performs a map operation that can call a recursive method without running out of stack space
<C2,R> Higher<C2,Active<W,R>>	traverseA(Applicative<C2> applicative, java.util.function.Function<? super T,? extends Higher<C2,R>> fn)
static <W,T,C2,R> Higher<C2,Active<W,R>>	traverseA(Applicative<C2> applicative, java.util.function.Function<? super T,? extends Higher<C2,R>> fn, Active<W,T> n)
Maybe<Active.Unfolds>	unfolds()
Active.Unfolds	unfolds(Unfoldable<W> unfoldable)
Active.Unfolds	unfoldsDefault()
<R> Active<W,R>	unit(R value)
<C,R> R	visit(java.util.function.Function<? super Higher<W,T>,? extends C> narrow, java.util.function.Function<? super C,? extends R> visitor)
<R> R	visit(java.util.function.Function<? super Higher<W,T>,? extends R> visitor)
<R> R	visitA(java.util.function.Function<? super Active<W,T>,? extends R> visitor)
Active<W,org.jooq.lambda.tuple.Tuple2<T,T>>	zip(Active<W,T> p2)
Active<W,org.jooq.lambda.tuple.Tuple3<T,T,T>>	zip(Active<W,T> p2, Active<W,T> p3)
<R> Active<W,R>	zip(Active<W,T> p2, Active<W,T> p3, Fn3<? super T,? super T,? super T,? extends R> zipper)
<R> Active<W,R>	zip(Active<W,T> p2, java.util.function.BiFunction<? super T,? super T,? extends R> zipper)
<R> Active<W,org.jooq.lambda.tuple.Tuple2<T,R>>	zip(Higher<W,R> fb)
<T2,R> Active<W,R>	zip(Higher<W,T2> fb, java.util.function.BiFunction<? super T,? super T2,? extends R> f)
<W2,T2,R> Active<W,R>	zipWith(Active<W2,T2> a, java.util.function.BiFunction<? super T,? super Maybe<T2>,? extends R> f)
<W2,T2,R> Active<W,R>	zipWith(Foldable<W2> foldable, Higher<W2,T2> a, java.util.function.BiFunction<? super T,? super Maybe<T2>,? extends R> f)
<R> Active<W,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>	zipWithIndex()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

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

to

Constructor Detail

Active

public Active()

Method Detail

of

public static <W,T> Active<W,T> of(Higher<W,T> single,
                                   InstanceDefinitions<W> def1)

of

public static <C,W,T> Active<W,T> of(java.util.function.Function<? super C,? extends Higher<W,T>> single,
                                     C c,
                                     InstanceDefinitions<W> def1)

of

public static <W,T> Active<W,T> of(InstanceDefinitions<W> def1,
                                   T value)

custom

public <S,R> Active<W,R> custom(java.util.function.Function<? super Higher<W,T>,? extends S> narrow,
                                java.util.function.Function<? super S,? extends Higher<W,R>> fn)

Perform a custom operation

     
       Active<list,Integer> active = Active.of(ListX.of(1,2,3), ListX.Instances.definitions());
      Active<list, ListX<Integer>> grouped = active.custom(ListX::narrowK, l -> l.grouped(10));
     
 

Type Parameters:

S - Concrete type

R - Return type

Parameters:

narrow - Function that narrows Higher Kinded encoding to it's concrete type

fn - Transformation function

Returns:

Transformed Active after custom operation

concreteConversion

public <S,R> Active.Converter<S> concreteConversion(java.util.function.Function<? super Higher<W,T>,? extends S> narrow)

Convert this Active to a new type via the underlying concrete type e.g. Given an Active List

     
     Active<list,Integer> active = Active.of(ListX.of(1,2,3), ListX.Instances.definitions());
     
 

We can convert it to a set via concreteConversion

     
      SetX<Integer> set = active.concreteConversion(ListX.<Integer>kindCokleisli())
                                      .to(ListX::toSetX());
     
 

Most cyclops-react types provide kindCokleisli implementations that convert a Higher Kinded encoding of the type back to the concrete type

Type Parameters:

S - Concrete type

R - Return type

Parameters:

narrow - Narrowing function (Cokleisli) to a concrete type

Returns:

Converter that works on the concrete type

visit

public <C,R> R visit(java.util.function.Function<? super Higher<W,T>,? extends C> narrow,
                     java.util.function.Function<? super C,? extends R> visitor)

visit

public <R> R visit(java.util.function.Function<? super Higher<W,T>,? extends R> visitor)

visitA

public <R> R visitA(java.util.function.Function<? super Active<W,T>,? extends R> visitor)

getActive

public Higher<W,T> getActive()

unit

public <R> Active<W,R> unit(R value)

filter

public Active<W,T> filter(java.util.function.Predicate<? super T> predicate)

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>

Parameters:

predicate - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

zip

public <R> Active<W,org.jooq.lambda.tuple.Tuple2<T,R>> zip(Higher<W,R> fb)

mapK

public <W2> Active<W2,T> mapK(FunctionK<W,W2,T> fn)

map

public <R> Active<W,R> 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>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

mapWithIndex

public <R> Active<W,R> mapWithIndex(java.util.function.BiFunction<? super T,java.lang.Long,? extends R> f)

intercalate

public T intercalate(Monoid<T> monoid,
                     T value)

anyMatch

public boolean anyMatch(java.util.function.Predicate<? super T> pred)

allMatch

public boolean allMatch(java.util.function.Predicate<? super T> pred)

getAt

public T getAt(int index)

reverse

public Active<W,T> reverse()

toListX

public ListX<T> toListX()

stream

public ReactiveSeq<T> stream()

size

public long size()

zipWithIndex

public <R> Active<W,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

zipWith

public <W2,T2,R> Active<W,R> zipWith(Active<W2,T2> a,
                                     java.util.function.BiFunction<? super T,? super Maybe<T2>,? extends R> f)

zipWith

public <W2,T2,R> Active<W,R> zipWith(Foldable<W2> foldable,
                                     Higher<W2,T2> a,
                                     java.util.function.BiFunction<? super T,? super Maybe<T2>,? extends R> f)

concreteMonoid

public <C> cyclops.typeclasses.Active.Narrowed<C> concreteMonoid(Kleisli<W,C,T> widen,
                                                                 Cokleisli<W,T,C> narrow)

concreteFlatMap

public <C,R> cyclops.typeclasses.Active.NarrowedFlatMap<C,R> concreteFlatMap(Kleisli<W,C,R> widen)

Use concreteFlatMap to access a flatMap operator that works with the concrete type (rather than the higher kind encoding) e.g. using a vavr Vector

     
     Active<vector,Integer> vector = Vectors.allTypeclasses(Vector.of(1,2,3));

     vector.concreteFlatMap(Vectors.kindKleisli())
                .flatMap(i->Vector.of(1,2,3)); //flatMap accepts Vector rather than Higher<vector,T>

     
 

Note this is not typically needed for cyclops-react types

concreteAp

public <C,R> cyclops.typeclasses.Active.NarrowedApplicative<C,R> concreteAp(Kleisli<W,C,java.util.function.Function<T,R>> widen)

concreteTailRec

public <C,R> cyclops.typeclasses.Active.NarrowedTailRec<C,R> concreteTailRec(Kleisli<W,C,Xor<T,R>> widen)

zip

public <T2,R> Active<W,R> zip(Higher<W,T2> fb,
                              java.util.function.BiFunction<? super T,? super T2,? extends R> f)

lazyZip

public <T2,R> Eval<Active<W,R>> lazyZip(Eval<Higher<W,T2>> lazy,
                                        java.util.function.BiFunction<? super T,? super T2,? extends R> fn)

lazyZipA

public <T2,R> Eval<Active<W,R>> lazyZipA(Eval<Active<W,T2>> lazy,
                                         java.util.function.BiFunction<? super T,? super T2,? extends R> fn)

peek

public Active<W,T> peek(java.util.function.Consumer<? super T> fn)

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:

fn - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

lift

public <R> java.util.function.Function<Active<W,T>,Active<W,R>> lift(java.util.function.Function<? super T,? extends R> fn)

zip

public Active<W,org.jooq.lambda.tuple.Tuple2<T,T>> zip(Active<W,T> p2)

zip

public <R> Active<W,R> zip(Active<W,T> p2,
                           java.util.function.BiFunction<? super T,? super T,? extends R> zipper)

zip

public Active<W,org.jooq.lambda.tuple.Tuple3<T,T,T>> zip(Active<W,T> p2,
                                                         Active<W,T> p3)

zip

public <R> Active<W,R> zip(Active<W,T> p2,
                           Active<W,T> p3,
                           Fn3<? super T,? super T,? super T,? extends R> zipper)

flatMap

public <R> Active<W,R> flatMap(java.util.function.Function<? super T,? extends Higher<W,R>> fn)

flatMapA

public <R> Active<W,R> flatMapA(java.util.function.Function<? super T,? extends Active<W,R>> fn)

ap

public <R> Active<W,R> ap(Higher<W,? extends java.util.function.Function<T,R>> fn)

ap

public <C,R> Active<W,R> ap(C c,
                            java.util.function.Function<? super C,? extends Higher<W,? extends java.util.function.Function<T,R>>> fn)

plus

public Active<W,T> plus(SemigroupK<W,T> semigroupK,
                        Higher<W,T> add)

plus

public Active<W,T> plus(SemigroupK<W,T> semigroupK,
                        Active<W,T> add)

unfolds

public Active.Unfolds unfolds(Unfoldable<W> unfoldable)

plus

public Active.Plus plus(MonadPlus<W> plus)

unfoldsDefault

public Active.Unfolds unfoldsDefault()

plusUnsafe

@Deprecated
public Active.Plus plusUnsafe()

Deprecated.

unfolds

public Maybe<Active.Unfolds> unfolds()

plus

public Maybe<Active.Plus> plus()

tailRec

public <R> Active<W,R> tailRec(T initial,
                               java.util.function.Function<? super T,? extends Higher<W,? extends Xor<T,R>>> fn)

tailRecA

public <R> Active<W,R> tailRecA(T initial,
                                java.util.function.Function<? super T,? extends Active<W,? extends Xor<T,R>>> fn)

foldMap

public <R> R foldMap(Monoid<R> mb,
                     java.util.function.Function<? super T,? extends R> fn)

foldRight

public T foldRight(Monoid<T> monoid)

foldRight

public T foldRight(T identity,
                   java.util.function.BinaryOperator<T> semigroup)

foldLeft

public T foldLeft(Monoid<T> monoid)

foldLeft

public T foldLeft(T identity,
                  java.util.function.BinaryOperator<T> semigroup)

flatTraverse

public <W2,R> Higher<W2,Higher<W,R>> flatTraverse(Applicative<W2> applicative,
                                                  java.util.function.Function<? super T,? extends Higher<W2,Higher<W,R>>> f)

traverseA

public <C2,R> Higher<C2,Active<W,R>> traverseA(Applicative<C2> applicative,
                                               java.util.function.Function<? super T,? extends Higher<C2,R>> fn)

traverseA

public static <W,T,C2,R> Higher<C2,Active<W,R>> traverseA(Applicative<C2> applicative,
                                                          java.util.function.Function<? super T,? extends Higher<C2,R>> fn,
                                                          Active<W,T> n)

sequenceA

public <C2,T> Higher<C2,Active<W,T>> sequenceA(Applicative<C2> applicative,
                                               Active<W,Higher<C2,T>> ds)

flatTraverseA

public <C2,R> Higher<C2,Active<W,R>> flatTraverseA(Applicative<C2> applicative,
                                                   java.util.function.Function<? super T,? extends Higher<C2,Active<W,R>>> f)

flatSequenceA

public <C2,T> Higher<C2,Active<W,T>> flatSequenceA(Applicative<C2> applicative,
                                                   Active<W,Higher<C2,Active<W,T>>> fgfa)

concat

public <W2> Product<W,W2,T> concat(Active<W2,T> active)

cast

public <U> Active<W,U> 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>

ofType

public <U> Active<W,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 Active<W,T> filterNot(java.util.function.Predicate<? super T> predicate)

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:

predicate - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

notNull

public Active<W,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

trampoline

public <R> Active<W,R> 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

retry

public <R> Active<W,R> 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

retry

public <R> Active<W,R> 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

forEach4

public <T2,R1,R2,R3,R> Active<W,R> forEach4(java.util.function.Function<? super T,? extends Higher<W,R1>> value1,
                                            java.util.function.BiFunction<? super T,? super R1,? extends Higher<W,R2>> value2,
                                            Fn3<? super T,? super R1,? super R2,? extends Higher<W,R3>> value3,
                                            Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

forEach4

public <T2,R1,R2,R3,R> Maybe<Active<W,R>> forEach4(java.util.function.Function<? super T,? extends Higher<W,R1>> value1,
                                                   java.util.function.BiFunction<? super T,? super R1,? extends Higher<W,R2>> value2,
                                                   Fn3<? super T,? super R1,? super R2,? extends Higher<W,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)

forEach3

public <T2,R1,R2,R> Active<W,R> forEach3(java.util.function.Function<? super T,? extends Higher<W,R1>> value1,
                                         java.util.function.BiFunction<? super T,? super R1,? extends Higher<W,R2>> value2,
                                         Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)

forEach3

public <T2,R1,R2,R> Maybe<Active<W,R>> forEach3(java.util.function.Function<? super T,? extends Higher<W,R1>> value1,
                                                java.util.function.BiFunction<? super T,? super R1,? extends Higher<W,R2>> value2,
                                                Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                                Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)

forEach2

public <R1,R> Active<W,R> forEach2(java.util.function.Function<? super T,? extends Higher<W,R1>> value1,
                                   java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

forEach2

public <R1,R> Maybe<Active<W,R>> forEach2(java.util.function.Function<? super T,? extends Higher<W,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)

show

public java.lang.String show()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object