CompletableFutureT (cyclops-react 2.0.0-MI6 API)

java.lang.Object
- com.aol.cyclops2.types.anyM.transformers.ValueTransformer<W,T>
- - cyclops.monads.transformers.CompletableFutureT<W,T>

Type Parameters:

T - Type of data stored inside the nested Future(s)

All Implemented Interfaces:

Unit<T>, Filters<T>, Folds<T>, To<CompletableFutureT<W,T>>, Transformable<T>, Unwrapable, Zippable<T>, Fn0<T>, java.lang.Iterable<T>, java.util.function.Supplier<T>, org.jooq.lambda.function.Function0<T>, org.reactivestreams.Publisher<T>
```
public final class CompletableFutureT<W extends WitnessType<W>,T>
extends ValueTransformer<W,T>
implements To<CompletableFutureT<W,T>>, Transformable<T>, Filters<T>
```
Monad Transformer for CompletableFuture's nested within another monadic type FutureT allows the deeply wrapped Future toNested be manipulating within it's nested /contained context

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.function.Fn0
  Fn0.FunctionalOperations<R>, Fn0.Instances, Fn0.SupplierKind<R>

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`<U> CompletableFutureT<W,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream toNested a given type, possibly throwing a `ClassCastException`.
`<T2,R> CompletableFutureT<W,R>`	`combine(Value<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)`
`<R> CompletableFutureT<W,R>`	`empty()`
`boolean`	`equals(java.lang.Object o)`
`CompletableFutureT<W,T>`	`filter(java.util.function.Predicate<? super T> test)` Keep only elements for which the supplied predicates hold e.g.
`CompletableFutureT<W,T>`	`filterNot(java.util.function.Predicate<? super T> predicate)` Remove any elements for which the predicate holds (inverse operation toNested filter) e.g.
`<B> CompletableFutureT<W,B>`	`flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends B>> f)`
`<R> CompletableFutureT<W,R>`	`flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)`
`<R> CompletableFutureT<W,R>`	`flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)`
`<B> CompletableFutureT<W,B>`	`flatMapT(java.util.function.Function<? super T,CompletableFutureT<W,B>> f)` Flat Map the wrapped Future
`<R1,R> CompletableFutureT<W,R>`	`forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<R1,R> CompletableFutureT<W,R>`	`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)`
`<R1,R> CompletableFutureT<W,R>`	`forEach2M(java.util.function.Function<? super T,? extends CompletableFutureT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<R1,R> CompletableFutureT<W,R>`	`forEach2M(java.util.function.Function<? super T,? extends CompletableFutureT<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> CompletableFutureT<W,R>`	`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)`
`<T2,R1,R2,R> CompletableFutureT<W,R>`	`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)`
`<T2,R1,R2,R> CompletableFutureT<W,R>`	`forEach3M(java.util.function.Function<? super T,? extends CompletableFutureT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends CompletableFutureT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<T2,R1,R2,R> CompletableFutureT<W,R>`	`forEach3M(java.util.function.Function<? super T,? extends CompletableFutureT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends CompletableFutureT<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> CompletableFutureT<W,R>`	`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)`
`<T2,R1,R2,R3,R> CompletableFutureT<W,R>`	`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)`
`<T2,R1,R2,R3,R> CompletableFutureT<W,R>`	`forEach4M(java.util.function.Function<? super T,? extends CompletableFutureT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends CompletableFutureT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends CompletableFutureT<W,R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`<T2,R1,R2,R3,R> CompletableFutureT<W,R>`	`forEach4M(java.util.function.Function<? super T,? extends CompletableFutureT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends CompletableFutureT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends CompletableFutureT<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)`
`static <W extends WitnessType<W>,A> CompletableFutureT<W,A>`	`fromAnyM(AnyM<W,A> anyM)` Construct an FutureWT from an AnyM that contains a monad type that contains type other than Future The values in the underlying monad will be mapped toNested CompletableFuture
`AnyM<W,? extends ReactiveSeq<T>>`	`generate()`
`int`	`hashCode()`
`AnyM<W,? extends ReactiveSeq<T>>`	`iterate(java.util.function.UnaryOperator<T> fn)` public AnyM> reactiveStream() { return this.transformerStream().map(v->v.reactiveStream()); }
`java.util.Iterator<T>`	`iterator()`
`static <W extends WitnessType<W>,U,R> java.util.function.Function<CompletableFutureT<W,U>,CompletableFutureT<W,R>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an FutureWT This allows multiple monad types toNested add functionality toNested existing function and methods e.g.
`static <W extends WitnessType<W>,U1,U2,R> java.util.function.BiFunction<CompletableFutureT<W,U1>,CompletableFutureT<W,U2>,CompletableFutureT<W,R>>`	`lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)` Lift a BiFunction into one that accepts and returns FutureWTs This allows multiple monad types toNested add functionality toNested existing function and methods e.g.
`<B> CompletableFutureT<W,B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped Future
`<B> CompletableFutureT<W,B>`	`map(java.util.function.Function<? super T,? extends B> f, java.util.concurrent.Executor ex)`
`java.lang.String`	`mkString()`
`CompletableFutureT<W,T>`	`notNull()` Filter elements retaining only values which are not null
`static <W extends WitnessType<W>,A> CompletableFutureT<W,A>`	`of(AnyM<W,java.util.concurrent.CompletableFuture<A>> monads)` Construct an FutureWT from an AnyM that wraps a monad containing FutureWs
`<U> CompletableFutureT<W,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a reactiveStream that are of a given type.
`CompletableFutureT<W,T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the Future
`ReactiveSeq<T>`	`stream()`
`java.lang.String`	`toString()`
`<R> CompletableFutureT<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
`AnyM<W,? extends MonadicValue<T>>`	`transformerStream()`
`<R> CompletableFutureT<W,R>`	`unit(R value)`
`protected <R> CompletableFutureT<W,R>`	`unitAnyM(AnyM<W,? super MonadicValue<R>> traversable)` Deprecated.
`<R> CompletableFutureT<W,R>`	`unitIterator(java.util.Iterator<R> it)`
`AnyM<W,java.util.concurrent.CompletableFuture<T>>`	`unwrap()` Unwrap a wrapped value
`<R> R`	`unwrapTo(java.util.function.Function<? super AnyM<W,java.util.concurrent.CompletableFuture<T>>,? extends R> fn)`
`CompletableFutureT<W,T>`	`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 Semigroups and Monoids for a large number of canned combinations).
`<T2,R> CompletableFutureT<W,R>`	`zip(java.lang.Iterable<? extends T2> iterable, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`<U> CompletableFutureT<W,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)` Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
`<S,U> CompletableFutureT<W,org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)` zip 3 Streams into one
`<S,U,R> CompletableFutureT<W,R>`	`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> CompletableFutureT<W,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`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> CompletableFutureT<W,R>`	`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> CompletableFutureT<W,R>`	`zipP(org.reactivestreams.Publisher<? extends T2> publisher, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`<U> CompletableFutureT<W,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`<U> CompletableFutureT<W,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipS(java.util.stream.Stream<? extends U> other)` Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
`<U,R> CompletableFutureT<W,R>`	`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> CompletableFutureT<W,R>`	`zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)`
`<R> CompletableFutureT<W,R>`	`zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)`
`<R> CompletableFutureT<W,R>`	`zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)`

Methods inherited from class com.aol.cyclops2.types.anyM.transformers.ValueTransformer
and, get, isPresent, negate, or, orElse, orElseGet, orElseThrow, subscribe, visit, zip

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.functor.Transformable
retry, retry

Methods inherited from interface com.aol.cyclops2.types.Unwrapable
unwrapIfInstance

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, singleOptional, startsWith, startsWithIterable, xMatch

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

Methods inherited from interface cyclops.function.Fn0
andThen, fnTo, functionOps, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, memoizeAsync, memoizeAsync, run, suspend, λ, λv

Methods inherited from interface org.jooq.lambda.function.Function0
apply, apply, from, toSupplier

Method Detail

iterator
```
public java.util.Iterator<T> iterator()
```
Specified by:

iterator in interface java.lang.Iterable<T>

stream
```
public ReactiveSeq<T> stream()
```
Specified by:

stream in interface Folds<T>

unwrap
```
public AnyM<W,java.util.concurrent.CompletableFuture<T>> unwrap()
```
Description copied from interface: Unwrapable

Unwrap a wrapped value

Specified by:

unwrap in interface Unwrapable

Returns:

The wrapped AnyM

unwrapTo

public <R> R unwrapTo(java.util.function.Function<? super AnyM<W,java.util.concurrent.CompletableFuture<T>>,? extends R> fn)

unitAnyM

@Deprecated
protected <R> CompletableFutureT<W,R> unitAnyM(AnyM<W,? super MonadicValue<R>> traversable)

Deprecated.

Specified by:: unitAnyM in class ValueTransformer<W extends WitnessType<W>,T>

transformerStream
```
public AnyM<W,? extends MonadicValue<T>> transformerStream()
```
Specified by:

transformerStream in class ValueTransformer<W extends WitnessType<W>,T>

filter
```
public CompletableFutureT<W,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 - toNested filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

peek

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

Peek at the current value of the Future

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

Specified by:: peek in interface Transformable<T>
Parameters:: peek - Consumer toNested accept current value of Future
Returns:: FutureWT with peek call

map

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

Map the wrapped Future

  
  FutureWT.of(AnyM.fromStream(Arrays.asFutureW(10))
             .map(t->t=t+1);
  
  
  //FutureWT<AnyMSeq<Stream<Future[11]>>>

Specified by:: map in interface Transformable<T>
Parameters:: f - Mapping function for the wrapped Future
Returns:: FutureWT that applies the map function toNested the wrapped Future

map

public <B> CompletableFutureT<W,B> map(java.util.function.Function<? super T,? extends B> f,
                                       java.util.concurrent.Executor ex)

flatMapT

public <B> CompletableFutureT<W,B> flatMapT(java.util.function.Function<? super T,CompletableFutureT<W,B>> f)

Flat Map the wrapped Future

  
  FutureWT.of(AnyM.fromStream(Arrays.asFutureW(10))
             .flatMap(t->Future.completedFuture(20));
  
  
  //FutureWT<AnyMSeq<Stream<Future[20]>>>

Parameters:: f - FlatMap function
Returns:: FutureWT that applies the flatMap function toNested the wrapped Future

flatMap

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

Specified by:: flatMap in class ValueTransformer<W extends WitnessType<W>,T>

lift

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

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

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

Parameters:: fn - Function toNested enhance with functionality from Future and another monad type
Returns:: Function that accepts and returns an FutureWT

lift2

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

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

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

Parameters:: fn - BiFunction toNested enhance with functionality from Future and another monad type
Returns:: Function that accepts and returns an FutureWT

fromAnyM
```
public static <W extends WitnessType<W>,A> CompletableFutureT<W,A> fromAnyM(AnyM<W,A> anyM)
```
Construct an FutureWT from an AnyM that contains a monad type that contains type other than Future The values in the underlying monad will be mapped toNested CompletableFuture

Parameters:

anyM - AnyM that doesn't contain a monad wrapping an Future

Returns:

FutureWT

of
```
public static <W extends WitnessType<W>,A> CompletableFutureT<W,A> of(AnyM<W,java.util.concurrent.CompletableFuture<A>> monads)
```
Construct an FutureWT from an AnyM that wraps a monad containing FutureWs

Parameters:

monads - AnyM that contains a monad wrapping an Future

Returns:

FutureWT

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

toString in class java.lang.Object

unitIterator

public <R> CompletableFutureT<W,R> unitIterator(java.util.Iterator<R> it)

unit

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

Specified by:: unit in interface Unit<T>

empty
```
public <R> CompletableFutureT<W,R> empty()
```
Specified by:

empty in class ValueTransformer<W extends WitnessType<W>,T>

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class java.lang.Object

equals
```
public boolean equals(java.lang.Object o)
```
Overrides:

equals in class java.lang.Object

combine

public <T2,R> CompletableFutureT<W,R> combine(Value<? extends T2> app,
                                              java.util.function.BiFunction<? super T,? super T2,? extends R> fn)

Overrides:: combine in class ValueTransformer<W extends WitnessType<W>,T>

zip
```
public CompletableFutureT<W,T> 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 Semigroups and Monoids for a large number of canned combinations). If this Applicative is a scalar value the provided value is combined with that value, otherwise the value is combined pair wise with all value in a non-scalar datastructure
Specified by:

zip in interface Zippable<T>

Overrides:

zip in class ValueTransformer<W extends WitnessType<W>,T>

Returns:

See Also:
Semigroup, Semigroups, Monoid,
To lift any Semigroup (or monoid) up toNested handling Applicatives use the combineApplicatives operator in Semigroups {@see com.aol.cyclops2.Semigroups#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid) } {@code BinaryOperator> sumMaybes = Semigroups.combineScalarFunctors(Semigroups.intSum); Maybe.just(1).zip(sumMaybes, Maybe.just(5)) //Maybe.just(6)); }

iterate
```
public AnyM<W,? extends ReactiveSeq<T>> iterate(java.util.function.UnaryOperator<T> fn)
```
Description copied from class: ValueTransformer

public AnyM> reactiveStream() { return this.transformerStream().map(v->v.reactiveStream()); }

Overrides:

iterate in class ValueTransformer<W extends WitnessType<W>,T>

generate
```
public AnyM<W,? extends ReactiveSeq<T>> generate()
```
Overrides:

generate in class ValueTransformer<W extends WitnessType<W>,T>

zip
```
public <T2,R> CompletableFutureT<W,R> zip(java.lang.Iterable<? extends T2> iterable,
                                          java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable using the supplied combining function

Specified by:

zip in interface Zippable<T>

Overrides:

zip in class ValueTransformer<W extends WitnessType<W>,T>

Parameters:

iterable - toNested zip with

fn - Zip function

Returns:

Combined zippable

zipP
```
public <T2,R> CompletableFutureT<W,R> zipP(org.reactivestreams.Publisher<? extends T2> publisher,
                                           java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function

Specified by:

zipP in interface Zippable<T>

Overrides:

zipP in class ValueTransformer<W extends WitnessType<W>,T>

Parameters:

publisher - toNested combine with

fn - Zip / combining function

Returns:

Combined zippable

zipS
```
public <U> CompletableFutureT<W,org.jooq.lambda.tuple.Tuple2<T,U>> 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>

Overrides:

zipS in class ValueTransformer<W extends WitnessType<W>,T>

Parameters:

other - Stream toNested combine with

Returns:

Combined Zippable

zip
```
public <U> CompletableFutureT<W,org.jooq.lambda.tuple.Tuple2<T,U>> 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>

Overrides:

zip in class ValueTransformer<W extends WitnessType<W>,T>

Parameters:

other - Iterable toNested combine with

Returns:

forEach4

public <T2,R1,R2,R3,R> CompletableFutureT<W,R> 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)

Overrides:: forEach4 in class ValueTransformer<W extends WitnessType<W>,T>

forEach4

public <T2,R1,R2,R3,R> CompletableFutureT<W,R> 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)

Overrides:: forEach4 in class ValueTransformer<W extends WitnessType<W>,T>

forEach3

public <T2,R1,R2,R> CompletableFutureT<W,R> 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)

Overrides:: forEach3 in class ValueTransformer<W extends WitnessType<W>,T>

forEach3

public <T2,R1,R2,R> CompletableFutureT<W,R> 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)

Overrides:: forEach3 in class ValueTransformer<W extends WitnessType<W>,T>

forEach2

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

Overrides:: forEach2 in class ValueTransformer<W extends WitnessType<W>,T>

forEach2

public <R1,R> CompletableFutureT<W,R> 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)

Overrides:: forEach2 in class ValueTransformer<W extends WitnessType<W>,T>

flatMapIterable

public <R> CompletableFutureT<W,R> flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)

Overrides:: flatMapIterable in class ValueTransformer<W extends WitnessType<W>,T>

flatMapPublisher

public <R> CompletableFutureT<W,R> flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

Overrides:: flatMapPublisher in class ValueTransformer<W extends WitnessType<W>,T>

forEach4M

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

forEach4M

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

forEach3M

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

forEach3M

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

forEach2M

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

forEach2M

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

mkString
```
public java.lang.String mkString()
```

cast
```
public <U> CompletableFutureT<W,U> cast(java.lang.Class<? extends U> type)
```
Description copied from interface: Transformable

Cast all elements in a reactiveStream toNested 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> CompletableFutureT<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 CompletableFutureT<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 toNested filter) e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 
```
Specified by:

filterNot in interface Filters<T>

Parameters:

predicate - toNested filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

notNull
```
public CompletableFutureT<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

zipWith

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

Specified by:: zipWith in interface Zippable<T>

zipWithS

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

Specified by:: zipWithS in interface Zippable<T>

zipWithP

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

Specified by:: zipWithP in interface Zippable<T>

trampoline

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

zipS
```
public <U,R> CompletableFutureT<W,R> 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 toNested combine with

zipper - Zip / combining function

Returns:

Combined zippable

zipP

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

Specified by:: zipP in interface Zippable<T>

zip3

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

Class CompletableFutureT<W extends WitnessType<W>,T>

Nested Class Summary

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

Method Summary

Methods inherited from class com.aol.cyclops2.types.anyM.transformers.ValueTransformer

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.aol.cyclops2.types.functor.Transformable

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

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface cyclops.function.Fn0

Methods inherited from interface org.jooq.lambda.function.Function0

Method Detail

iterator

stream

unwrap

unwrapTo

unitAnyM

transformerStream

filter

peek

map

map

flatMapT

flatMap

lift

lift2

fromAnyM

of

toString

unitIterator

unit

empty

hashCode

equals

combine

zip

iterate

generate

zip

zipP

zipS

zip

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

flatMapIterable

flatMapPublisher

forEach4M

forEach4M

forEach3M

forEach3M

forEach2M

forEach2M

mkString

cast

ofType

filterNot

notNull

zipWith

zipWithS

zipWithP

trampoline

zipS

zipP

zip3

zip3

zip4

zip4