Coproduct (cyclops-reactor 9.0.0-FINAL API)

java.lang.Object
- cyclops.typeclasses.Coproduct<W1,W2,T>

All Implemented Interfaces:

Convert<Higher<Higher<Higher<Witness.coproduct,W1>,W2>,T>>, Higher<Higher<Higher<Witness.coproduct,W1>,W2>,T>, Higher2<Higher<Witness.coproduct,W1>,W2,T>, Higher3<Witness.coproduct,W1,W2,T>, Filters<T>, To<Coproduct<W1,W2,T>>, Transformable<T>
```
public class Coproduct<W1,W2,T>
extends java.lang.Object
implements Filters<T>, Higher3<Witness.coproduct,W1,W2,T>, Transformable<T>, To<Coproduct<W1,W2,T>>
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Coproduct.Instances<W1,W2>

class Coproduct.Plus

class Coproduct.Unfolds

Nested Classes
Modifier and Type	Class and Description
`static class`	`Coproduct.Instances<W1,W2>`
`class`	`Coproduct.Plus`
`class`	`Coproduct.Unfolds`

Constructor Summary

Constructors
Constructor and Description

Coproduct()

Constructors
Constructor and Description
`Coproduct()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Active<W1,T>`	`activeLeft(MonoidK<W1,T> m, Higher<W1,T> concat)`
`Active<W2,T>`	`activeSecond(MonoidK<W2,T> m, Higher<W2,T> concat)`
`Xor<Active<W1,T>,Active<W2,T>>`	`asActiveXor()`
`Xor<Higher<W1,T>,Higher<W2,T>>`	`asXor()`
`<U> Coproduct<W1,W2,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream to a given type, possibly throwing a `ClassCastException`.
`<R> Coproduct<W1,W2,R>`	`coflatMap(java.util.function.Function<? super Coproduct<W1,W2,T>,R> mapper)`
`static <W1,T> Coproduct<W1,Witness.completableFuture,T>`	`completableFutureOf(java.util.function.Supplier<T> value, java.util.concurrent.Executor ex, InstanceDefinitions<W1> def1)`
`static <W1,X extends java.lang.Throwable,T> Coproduct<W1,Higher<Witness.tryType,X>,T>`	`failure(X value, InstanceDefinitions<W1> def1)`
`Coproduct<W1,W2,T>`	`filter(java.util.function.Predicate<? super T> test)` Keep only elements for which the supplied predicates hold e.g.
`Coproduct<W1,W2,T>`	`filterNot(java.util.function.Predicate<? super T> predicate)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`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)`
`static <W1,T> Coproduct<W1,Witness.future,T>`	`futureOf(java.util.function.Supplier<T> value, java.util.concurrent.Executor ex, InstanceDefinitions<W1> def1)`
`static <W1,T> Coproduct<W1,Witness.maybe,T>`	`just(T value, InstanceDefinitions<W1> def1)`
`static <W1,T> Coproduct<W1,Witness.eval,T>`	`later(java.util.function.Supplier<T> value, InstanceDefinitions<W1> def1)`
`static <W1,W2,T> Coproduct<W1,W2,T>`	`left(Higher<W1,T> left, InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2)`
`static <W1,T> Coproduct<W1,Witness.linkedListX,T>`	`linkedListX(InstanceDefinitions<W1> def1, T... values)`
`static <W1,T> Coproduct<W1,Witness.linkedListX,T>`	`linkedListX(LinkedListX<T> list, InstanceDefinitions<W1> def1)`
`static <W1,T> Coproduct<W1,Witness.list,T>`	`listX(InstanceDefinitions<W1> def1, T... values)`
`static <W1,T> Coproduct<W1,Witness.list,T>`	`listX(java.util.List<T> list, InstanceDefinitions<W1> def1)`
`<R> Coproduct<W1,W2,R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> Coproduct<W1,W2,R>`	`mapWithIndex(java.util.function.BiFunction<? super T,java.lang.Long,? extends R> f)`
`static <W1,T> Coproduct<W1,Witness.maybe,T>`	`maybeNullabe(T value, InstanceDefinitions<W1> def1)`
`static <W1,W2,T> Coproduct<W1,W2,T>`	`narrowK(Higher<Higher<Higher<Witness.coproduct,W1>,W2>,T> ds)`
`static <W1,T> Coproduct<W1,Witness.maybe,T>`	`none(InstanceDefinitions<W1> def1)`
`Coproduct<W1,W2,T>`	`notNull()` Filter elements retaining only values which are not null
`static <W1,W2,T> Coproduct<W1,W2,T>`	`of(Xor<Higher<W1,T>,Higher<W2,T>> xor, InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2)`
`static <W1,T> Coproduct<W1,Witness.optional,T>`	`ofNullable(T value, InstanceDefinitions<W1> def1)`
`<U> Coproduct<W1,W2,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a reactiveStream that are of a given type.
`Coproduct<W1,W2,T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`Maybe<Coproduct.Plus>`	`plus()`
`Coproduct<W1,W2,T>`	`plusLeft(SemigroupK<W1,T> semigroupK, Higher<W1,T> add)`
`Coproduct<W1,W2,T>`	`plusRight(SemigroupK<W2,T> semigroupK, Higher<W2,T> add)`
`Product<W1,W2,T>`	`product(MonoidK<W1,T> m1, MonoidK<W2,T> m2)`
`static <W1,T> Coproduct<W1,Witness.reactiveSeq,T>`	`reactiveSeq(InstanceDefinitions<W1> def1, T... values)`
`static <W1,T> Coproduct<W1,Witness.reactiveSeq,T>`	`reactiveSeq(ReactiveSeq<T> stream, InstanceDefinitions<W1> def1)`
`<R> Coproduct<W1,W2,R>`	`retry(java.util.function.Function<? super T,? extends R> fn)` Retry a transformation if it fails.
`<R> Coproduct<W1,W2,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.
`Coproduct<W1,W2,T>`	`reverse()`
`static <W1,W2,T> Coproduct<W1,W2,T>`	`right(Higher<W2,T> right, InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2)`
`<C2,T> Higher<C2,Coproduct<W1,W2,T>>`	`sequenceA(Applicative<C2> applicative, Coproduct<W1,W2,Higher<C2,T>> ds)`
`long`	`size()`
`ReactiveSeq<T>`	`stream()`
`static <W1,T> Coproduct<W1,Witness.stream,T>`	`stream(InstanceDefinitions<W1> def1, T... values)`
`static <W1,T> Coproduct<W1,Witness.stream,T>`	`stream(java.util.stream.Stream<T> stream, InstanceDefinitions<W1> def1)`
`static <W1,X extends java.lang.Throwable,T> Coproduct<W1,Higher<Witness.tryType,X>,T>`	`success(T value, InstanceDefinitions<W1> def1)`
`Coproduct<W2,W1,T>`	`swap()`
`ListX<T>`	`toListX()`
`java.lang.String`	`toString()`
`<R> Coproduct<W1,W2,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
`static <W1,W2,T,C2,R> Higher<C2,Coproduct<W1,W2,R>>`	`traverseA(Applicative<C2> applicative, java.util.function.Function<? super T,? extends Higher<C2,R>> fn, Coproduct<W1,W2,T> n)`
`<W3,R> Higher<W3,Coproduct<W1,W2,R>>`	`traverseA(Applicative<W3> applicative, java.util.function.Function<? super T,Higher<W3,R>> f)`
`Maybe<Coproduct.Unfolds>`	`unfolds()`
`Coproduct.Unfolds`	`unfoldsDefault()`
`static <W1,T> Coproduct<W1,Witness.vectorX,T>`	`vectorX(InstanceDefinitions<W1> def1, T... values)`
`static <W1,T> Coproduct<W1,Witness.vectorX,T>`	`vectorX(VectorX<T> list, InstanceDefinitions<W1> def1)`
`<R> R`	`visit(java.util.function.Function<? super Higher<W1,? super T>,? extends R> left, java.util.function.Function<? super Higher<W2,? super T>,? extends R> right)`
`<R> Coproduct<W1,W2,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.hkt.Higher
applyHKT_, applyHKT, applyHKT

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

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

Constructor Detail
- Coproduct
```
public Coproduct()
```

Method Detail

of

public static <W1,W2,T> Coproduct<W1,W2,T> of(Xor<Higher<W1,T>,Higher<W2,T>> xor,
                                              InstanceDefinitions<W1> def1,
                                              InstanceDefinitions<W2> def2)

right

public static <W1,W2,T> Coproduct<W1,W2,T> right(Higher<W2,T> right,
                                                 InstanceDefinitions<W1> def1,
                                                 InstanceDefinitions<W2> def2)

left

public static <W1,W2,T> Coproduct<W1,W2,T> left(Higher<W1,T> left,
                                                InstanceDefinitions<W1> def1,
                                                InstanceDefinitions<W2> def2)

filter
```
public Coproduct<W1,W2,T> filter(java.util.function.Predicate<? super T> test)
```
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:

test - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

coflatMap

public <R> Coproduct<W1,W2,R> coflatMap(java.util.function.Function<? super Coproduct<W1,W2,T>,R> mapper)

ofType

public <U> Coproduct<W1,W2,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>

activeLeft

public Active<W1,T> activeLeft(MonoidK<W1,T> m,
                               Higher<W1,T> concat)

activeSecond

public Active<W2,T> activeSecond(MonoidK<W2,T> m,
                                 Higher<W2,T> concat)

plusLeft

public Coproduct<W1,W2,T> plusLeft(SemigroupK<W1,T> semigroupK,
                                   Higher<W1,T> add)

plusRight

public Coproduct<W1,W2,T> plusRight(SemigroupK<W2,T> semigroupK,
                                    Higher<W2,T> add)

product

public Product<W1,W2,T> product(MonoidK<W1,T> m1,
                                MonoidK<W2,T> m2)

filterNot
```
public Coproduct<W1,W2,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 Coproduct<W1,W2,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

cast
```
public <U> Coproduct<W1,W2,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>

map
```
public <R> Coproduct<W1,W2,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> Coproduct<W1,W2,R> mapWithIndex(java.util.function.BiFunction<? super T,java.lang.Long,? extends R> f)

zipWithIndex

public <R> Coproduct<W1,W2,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

asXor

public Xor<Higher<W1,T>,Higher<W2,T>> asXor()

asActiveXor

public Xor<Active<W1,T>,Active<W2,T>> asActiveXor()

peek
```
public Coproduct<W1,W2,T> peek(java.util.function.Consumer<? super T> c)
```
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:

c - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

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

toString in class java.lang.Object

trampoline

public <R> Coproduct<W1,W2,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> Coproduct<W1,W2,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> Coproduct<W1,W2,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

visit

public <R> R visit(java.util.function.Function<? super Higher<W1,? super T>,? extends R> left,
                   java.util.function.Function<? super Higher<W2,? super T>,? extends R> right)

swap
```
public Coproduct<W2,W1,T> swap()
```

plus
```
public Maybe<Coproduct.Plus> plus()
```

unfoldsDefault

public Coproduct.Unfolds unfoldsDefault()

unfolds

public Maybe<Coproduct.Unfolds> unfolds()

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)

toListX
```
public ListX<T> toListX()
```

stream
```
public ReactiveSeq<T> stream()
```

reverse
```
public Coproduct<W1,W2,T> reverse()
```

size
```
public long size()
```

foldLeft
```
public T foldLeft(Monoid<T> monoid)
```

foldLeft

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

traverseA

public <W3,R> Higher<W3,Coproduct<W1,W2,R>> traverseA(Applicative<W3> applicative,
                                                      java.util.function.Function<? super T,Higher<W3,R>> f)

traverseA

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

sequenceA

public <C2,T> Higher<C2,Coproduct<W1,W2,T>> sequenceA(Applicative<C2> applicative,
                                                      Coproduct<W1,W2,Higher<C2,T>> ds)

vectorX

public static <W1,T> Coproduct<W1,Witness.vectorX,T> vectorX(VectorX<T> list,
                                                             InstanceDefinitions<W1> def1)

vectorX

public static <W1,T> Coproduct<W1,Witness.vectorX,T> vectorX(InstanceDefinitions<W1> def1,
                                                             T... values)

linkedListX

public static <W1,T> Coproduct<W1,Witness.linkedListX,T> linkedListX(LinkedListX<T> list,
                                                                     InstanceDefinitions<W1> def1)

linkedListX

public static <W1,T> Coproduct<W1,Witness.linkedListX,T> linkedListX(InstanceDefinitions<W1> def1,
                                                                     T... values)

listX

public static <W1,T> Coproduct<W1,Witness.list,T> listX(java.util.List<T> list,
                                                        InstanceDefinitions<W1> def1)

listX

public static <W1,T> Coproduct<W1,Witness.list,T> listX(InstanceDefinitions<W1> def1,
                                                        T... values)

stream

public static <W1,T> Coproduct<W1,Witness.stream,T> stream(java.util.stream.Stream<T> stream,
                                                           InstanceDefinitions<W1> def1)

stream

public static <W1,T> Coproduct<W1,Witness.stream,T> stream(InstanceDefinitions<W1> def1,
                                                           T... values)

reactiveSeq

public static <W1,T> Coproduct<W1,Witness.reactiveSeq,T> reactiveSeq(ReactiveSeq<T> stream,
                                                                     InstanceDefinitions<W1> def1)

reactiveSeq

public static <W1,T> Coproduct<W1,Witness.reactiveSeq,T> reactiveSeq(InstanceDefinitions<W1> def1,
                                                                     T... values)

success

public static <W1,X extends java.lang.Throwable,T> Coproduct<W1,Higher<Witness.tryType,X>,T> success(T value,
                                                                                                     InstanceDefinitions<W1> def1)

failure

public static <W1,X extends java.lang.Throwable,T> Coproduct<W1,Higher<Witness.tryType,X>,T> failure(X value,
                                                                                                     InstanceDefinitions<W1> def1)

futureOf

public static <W1,T> Coproduct<W1,Witness.future,T> futureOf(java.util.function.Supplier<T> value,
                                                             java.util.concurrent.Executor ex,
                                                             InstanceDefinitions<W1> def1)

completableFutureOf

public static <W1,T> Coproduct<W1,Witness.completableFuture,T> completableFutureOf(java.util.function.Supplier<T> value,
                                                                                   java.util.concurrent.Executor ex,
                                                                                   InstanceDefinitions<W1> def1)

later

public static <W1,T> Coproduct<W1,Witness.eval,T> later(java.util.function.Supplier<T> value,
                                                        InstanceDefinitions<W1> def1)

ofNullable

public static <W1,T> Coproduct<W1,Witness.optional,T> ofNullable(T value,
                                                                 InstanceDefinitions<W1> def1)

just

public static <W1,T> Coproduct<W1,Witness.maybe,T> just(T value,
                                                        InstanceDefinitions<W1> def1)

none

public static <W1,T> Coproduct<W1,Witness.maybe,T> none(InstanceDefinitions<W1> def1)

maybeNullabe

public static <W1,T> Coproduct<W1,Witness.maybe,T> maybeNullabe(T value,
                                                                InstanceDefinitions<W1> def1)

narrowK

public static <W1,W2,T> Coproduct<W1,W2,T> narrowK(Higher<Higher<Higher<Witness.coproduct,W1>,W2>,T> ds)

Class Coproduct<W1,W2,T>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

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

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

Constructor Detail

Coproduct

Method Detail

of

right

left

filter

coflatMap

ofType

activeLeft

activeSecond

plusLeft

plusRight

product

filterNot

notNull

cast

map

mapWithIndex

zipWithIndex

asXor

asActiveXor

peek

toString

trampoline

retry

retry

visit

swap

plus

unfoldsDefault

unfolds

foldMap

foldRight

foldRight

toListX

stream

reverse

size

foldLeft

foldLeft

traverseA

traverseA

sequenceA

vectorX

vectorX

linkedListX

linkedListX

listX

listX

stream

stream

reactiveSeq

reactiveSeq

success

failure

futureOf

completableFutureOf

later

ofNullable

just

none

maybeNullabe

narrowK