CompletableFutureT (cyclops-react 1.0.3 API)

Type Parameters:

A - Type of data stored inside the nested CompletableFutures

All Superinterfaces:

ConvertableToReactiveSeq<A>, Filterable<A>, Foldable<A>, Functor<A>, java.lang.Iterable<A>, org.reactivestreams.Publisher<A>, To<CompletableFutureT<A>>, ToStream<A>, Unit<A>

All Known Implementing Classes:

CompletableFutureTSeq, CompletableFutureTValue
```
public interface CompletableFutureT<A>
extends To<CompletableFutureT<A>>, Unit<A>, org.reactivestreams.Publisher<A>, Functor<A>, Foldable<A>, Filterable<A>, ToStream<A>
```
Monad Transformer for Java CompletableFutures CompletableFutureT allows the deeply wrapped CompletableFuture to be manipulating within it's nested /contained context

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <B> CompletableFutureT<B>`	`bind(java.util.function.Function<? super A,CompletableFutureT<? extends B>> f)`
`default <U> CompletableFutureT<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`<R> CompletableFutureT<R>`	`empty()`
`static <T> CompletableFutureTSeq<T>`	`emptyList()`
`static <T> CompletableFutureTValue<T>`	`emptyMaybe()`
`MaybeT<A>`	`filter(java.util.function.Predicate<? super A> test)` Keep only elements for which the supplied predicates hold e.g.
`default MaybeT<A>`	`filterNot(java.util.function.Predicate<? super A> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<B> CompletableFutureT<B>`	`flatMap(java.util.function.Function<? super A,? extends MonadicValue<? extends B>> f)`
`static <A> CompletableFutureT<A>`	`fromAnyM(AnyM<A> anyM)`
`static <A> CompletableFutureTSeq<A>`	`fromAnyMSeq(AnyMSeq<A> anyM)`
`static <A> CompletableFutureTValue<A>`	`fromAnyMValue(AnyMValue<A> anyM)`
`static <A> CompletableFutureTValue<A>`	`fromFuture(java.util.concurrent.CompletableFuture<java.util.concurrent.CompletableFuture<A>> future)`
`static <A> CompletableFutureTSeq<A>`	`fromIterable(java.lang.Iterable<java.util.concurrent.CompletableFuture<A>> iterableOfCompletableFutures)`
`static <A> CompletableFutureTValue<A>`	`fromIterableValue(java.lang.Iterable<java.util.concurrent.CompletableFuture<A>> iterableOfCompletableFutures)`
`static <A> CompletableFutureTValue<A>`	`fromOptional(java.util.Optional<java.util.concurrent.CompletableFuture<A>> optional)`
`static <A> CompletableFutureTSeq<A>`	`fromPublisher(org.reactivestreams.Publisher<java.util.concurrent.CompletableFuture<A>> publisherOfCompletableFutures)`
`static <A> CompletableFutureTSeq<A>`	`fromStream(java.util.stream.Stream<java.util.concurrent.CompletableFuture<A>> streamOfCompletableFutures)`
`static <A,V extends MonadicValue<java.util.concurrent.CompletableFuture<A>>> CompletableFutureTValue<A>`	`fromValue(V monadicValue)`
`static <U,R> java.util.function.Function<CompletableFutureT<U>,CompletableFutureT<R>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an CompletableFutureT This allows multiple monad types to add functionality to existing functions and methods e.g.
`static <U1,U2,R> java.util.function.BiFunction<CompletableFutureT<U1>,CompletableFutureT<U2>,CompletableFutureT<R>>`	`lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)` Lift a BiFunction into one that accepts and returns CompletableFutureTs This allows multiple monad types to add functionality to existing functions and methods e.g.
`<B> CompletableFutureT<B>`	`map(java.util.function.Function<? super A,? extends B> f)` Map the wrapped CompletableFuture
`default MaybeT<A>`	`notNull()` Filter elements retaining only values which are not null
`static <A> CompletableFutureT<A>`	`of(AnyM<java.util.concurrent.CompletableFuture<A>> monads)` Construct an MaybeT from an AnyM that wraps a monad containing Maybes
`default <U> MaybeT<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default <R> CompletableFutureT<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<A,R>,Matchable.CheckValue1<A,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`CompletableFutureT<A>`	`peek(java.util.function.Consumer<? super A> peek)` Peek at the current value of the CompletableFuture
`default ReactiveSeq<A>`	`stream()`
`default <R> CompletableFutureT<R>`	`trampoline(java.util.function.Function<? super A,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`AnyM<java.util.concurrent.CompletableFuture<A>>`	`unwrap()`

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

Methods inherited from interface com.aol.cyclops.types.Unit
unit

Methods inherited from interface org.reactivestreams.Publisher
subscribe

Methods inherited from interface com.aol.cyclops.types.Foldable
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, xMatch

Methods inherited from interface com.aol.cyclops.types.stream.ToStream
futureStream, getStreamable, isEmpty, iterator, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Method Detail

empty
```
<R> CompletableFutureT<R> empty()
```

filter
```
MaybeT<A> filter(java.util.function.Predicate<? super A> test)
```
Description copied from interface: Filterable
Keep only elements for which the supplied predicates hold e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[3]
   
 
 
```
Specified by:

filter in interface Filterable<A>

Parameters:

test - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

bind

default <B> CompletableFutureT<B> bind(java.util.function.Function<? super A,CompletableFutureT<? extends B>> f)

of
```
static <A> CompletableFutureT<A> of(AnyM<java.util.concurrent.CompletableFuture<A>> monads)
```
Construct an MaybeT from an AnyM that wraps a monad containing Maybes

Parameters:

monads - AnyM that contains a monad wrapping an Maybe

Returns:

MaybeT

unwrap

AnyM<java.util.concurrent.CompletableFuture<A>> unwrap()

Returns:: The wrapped AnyM

peek

CompletableFutureT<A> peek(java.util.function.Consumer<? super A> peek)

Peek at the current value of the CompletableFuture

  
    CompletableFutureT.of(AnyM.fromStream(Arrays.asCompletableFuture(10))
             .peek(System.out::println);
             
     //prints 10

Specified by:: peek in interface Functor<A>
Parameters:: peek - Consumer to accept current value of CompletableFuture
Returns:: CompletableFutureT with peek call

map

<B> CompletableFutureT<B> map(java.util.function.Function<? super A,? extends B> f)

Map the wrapped CompletableFuture

  
  CompletableFutureT.of(AnyM.fromStream(Arrays.asCompletableFuture(10))
             .map(t->t=t+1);
  
  
  //CompletableFutureT<AnyM<Stream<CompletableFuture[11]>>>

Specified by:: map in interface Functor<A>
Parameters:: f - Mapping function for the wrapped CompletableFuture
Returns:: CompletableFutureT that applies the map function to the wrapped CompletableFuture

flatMap

<B> CompletableFutureT<B> flatMap(java.util.function.Function<? super A,? extends MonadicValue<? extends B>> f)

lift

static <U,R> java.util.function.Function<CompletableFutureT<U>,CompletableFutureT<R>> lift(java.util.function.Function<? super U,? extends R> fn)

Lift a function into one that accepts and returns an CompletableFutureT This allows multiple monad types to add functionality to existing functions and methods e.g. to add list handling / iteration (via CompletableFuture) and iteration (via Stream) to an existing function

  
        Function<Integer,Integer> add2 = i -> i+2;
    	Function<CompletableFutureT<Integer>, CompletableFutureT<Integer>> optTAdd2 = CompletableFutureT.lift(add2);
    	
    	Stream<Integer> withNulls = Stream.of(1,2,3);
    	AnyM<Integer> stream = AnyM.fromStream(withNulls);
    	AnyM<CompletableFuture<Integer>> streamOpt = stream.map(CompletableFuture::completedFuture);
    	List<Integer> results = optTAdd2.apply(CompletableFutureT.of(streamOpt))
    									.unwrap()
    									.<Stream<CompletableFuture<Integer>>>unwrap()
    									.map(CompletableFuture::join)
    									.collect(Collectors.toList());
    	
    	
    	//CompletableFuture.completedFuture(List[3,4]);

Parameters:: fn - Function to enhance with functionality from CompletableFuture and another monad type
Returns:: Function that accepts and returns an CompletableFutureT

lift2

static <U1,U2,R> java.util.function.BiFunction<CompletableFutureT<U1>,CompletableFutureT<U2>,CompletableFutureT<R>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)

Lift a BiFunction into one that accepts and returns CompletableFutureTs This allows multiple monad types to add functionality to existing functions and methods e.g. to add list handling / iteration (via CompletableFuture), iteration (via Stream) and asynchronous execution (CompletableFuture) to an existing function

  
    	BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;
    	BiFunction<CompletableFutureT<Integer>,CompletableFutureT<Integer>,CompletableFutureT<Integer>> optTAdd2 = CompletableFutureT.lift2(add);
    	
    	Stream<Integer> withNulls = Stream.of(1,2,3);
    	AnyM<Integer> stream = AnyM.ofMonad(withNulls);
    	AnyM<CompletableFuture<Integer>> streamOpt = stream.map(CompletableFuture::completedFuture);
    	
    	CompletableFuture<CompletableFuture<Integer>> two = CompletableFuture.completedFuture(CompletableFuture.completedFuture(2));
    	AnyM<CompletableFuture<Integer>> future=  AnyM.fromCompletableFuture(two);
    	List<Integer> results = optTAdd2.apply(CompletableFutureT.of(streamOpt),CompletableFutureT.of(future))
    									.unwrap()
    									.<Stream<CompletableFuture<Integer>>>unwrap()
    									.map(CompletableFuture::join)
    									.collect(Collectors.toList());
    									
    		//CompletableFuture.completedFuture(List[3,4,5]);

Parameters:: fn - BiFunction to enhance with functionality from CompletableFuture and another monad type
Returns:: Function that accepts and returns an CompletableFutureT

fromAnyM

static <A> CompletableFutureT<A> fromAnyM(AnyM<A> anyM)

fromAnyMValue

static <A> CompletableFutureTValue<A> fromAnyMValue(AnyMValue<A> anyM)

fromAnyMSeq

static <A> CompletableFutureTSeq<A> fromAnyMSeq(AnyMSeq<A> anyM)

fromIterable

static <A> CompletableFutureTSeq<A> fromIterable(java.lang.Iterable<java.util.concurrent.CompletableFuture<A>> iterableOfCompletableFutures)

fromStream

static <A> CompletableFutureTSeq<A> fromStream(java.util.stream.Stream<java.util.concurrent.CompletableFuture<A>> streamOfCompletableFutures)

fromPublisher

static <A> CompletableFutureTSeq<A> fromPublisher(org.reactivestreams.Publisher<java.util.concurrent.CompletableFuture<A>> publisherOfCompletableFutures)

fromValue

static <A,V extends MonadicValue<java.util.concurrent.CompletableFuture<A>>> CompletableFutureTValue<A> fromValue(V monadicValue)

fromOptional

static <A> CompletableFutureTValue<A> fromOptional(java.util.Optional<java.util.concurrent.CompletableFuture<A>> optional)

fromFuture

static <A> CompletableFutureTValue<A> fromFuture(java.util.concurrent.CompletableFuture<java.util.concurrent.CompletableFuture<A>> future)

fromIterableValue

static <A> CompletableFutureTValue<A> fromIterableValue(java.lang.Iterable<java.util.concurrent.CompletableFuture<A>> iterableOfCompletableFutures)

emptyMaybe

static <T> CompletableFutureTValue<T> emptyMaybe()

emptyList

static <T> CompletableFutureTSeq<T> emptyList()

cast
```
default <U> CompletableFutureT<U> cast(java.lang.Class<? extends U> type)
```
Description copied from interface: Functor

Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Functor<A>

trampoline

default <R> CompletableFutureT<R> trampoline(java.util.function.Function<? super A,? extends Trampoline<? extends R>> mapper)

Description copied from interface: Functor

Performs a map operation that can call a recursive method without running out of stack space

 
 ReactiveSeq.of(10,20,30,40)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println); 
    			 
    	Trampoline<Long> fibonacci(int i){
    		return fibonacci(i,1,0);
    	}
    	Trampoline<Long> fibonacci(int n, long a, long b) {
        	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
    	}		 
    			 
 55
    	6765
    	832040
    	102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);
    			 
    			 
 completes successfully

Specified by:: trampoline in interface Functor<A>
Parameters:: mapper - TCO Transformation function
Returns:: Functor transformed by the supplied transformation function

patternMatch

default <R> CompletableFutureT<R> patternMatch(java.util.function.Function<Matchable.CheckValue1<A,R>,Matchable.CheckValue1<A,R>> case1,
                                               java.util.function.Supplier<? extends R> otherwise)

Description copied from interface: Functor

Transform the elements of this Stream with a Pattern Matching case and default value

 
 List<String> result = CollectionX.of(1,2,3,4)
                                             .patternMatch(
                                                       c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
                                                     )
 
 // CollectionX["odd","even","odd","even"]

Specified by:: patternMatch in interface Functor<A>
Parameters:: case1 - Function to generate a case (or chain of cases as a single case); otherwise - Value if supplied case doesn't match
Returns:: CollectionX where elements are transformed by pattern matching

ofType

default <U> MaybeT<U> ofType(java.lang.Class<? extends U> type)

Description copied from interface: Filterable

Keep only those elements in a stream that are of a given type.

  
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)

Specified by:: ofType in interface Filterable<A>

filterNot
```
default MaybeT<A> filterNot(java.util.function.Predicate<? super A> fn)
```
Description copied from interface: Filterable
Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 
```
Specified by:

filterNot in interface Filterable<A>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

notNull
```
default MaybeT<A> notNull()
```
Description copied from interface: Filterable
Filter elements retaining only values which are not null
```
  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
 
```
Specified by:

notNull in interface Filterable<A>

Returns:

Filterable with nulls removed

stream
```
default ReactiveSeq<A> stream()
```
Specified by:

stream in interface Foldable<A>

Specified by:

stream in interface ToStream<A>

Returns:

this Foldable converted to a Stream (ReactiveSeq) of it's elements

Interface CompletableFutureT<A>

Method Summary

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

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

Methods inherited from interface org.reactivestreams.Publisher

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

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

Methods inherited from interface java.lang.Iterable