cyclops.monads.transformers

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

java.lang.Object

com.aol.cyclops2.types.anyM.transformers.ValueTransformer<W,T>

cyclops.monads.transformers.MaybeT<W,T>

Type Parameters:

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

All Implemented Interfaces:

Unit<T>, Filters<T>, Folds<T>, To<MaybeT<W,T>>, Transformable<T>, Unwrapable, Zippable<T>, Fn0<T>, java.lang.Iterable<T>, java.util.function.Supplier<T>, org.reactivestreams.Publisher<T>

public final class MaybeT<W extends WitnessType<W>,T>
extends ValueTransformer<W,T>
implements To<MaybeT<W,T>>, Transformable<T>, Filters<T>

Monad Transformer for Maybe's MaybeT allows the deeply wrapped Maybe to 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

Modifier and Type	Method and Description
<U> MaybeT<W,U>	cast(java.lang.Class<? extends U> type) Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException.
<T2,R> MaybeT<W,R>	combine(Value<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
<R> MaybeT<W,R>	empty()
boolean	equals(java.lang.Object o)
MaybeT<W,T>	filter(java.util.function.Predicate<? super T> test) Keep only elements for which the supplied predicates hold e.g.
MaybeT<W,T>	filterNot(java.util.function.Predicate<? super T> predicate) Remove any elements for which the predicate holds (inverse operation to filter) e.g.
<B> MaybeT<W,B>	flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends B>> f)
<R> MaybeT<W,R>	flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
<R> MaybeT<W,R>	flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
<B> MaybeT<W,B>	flatMapT(java.util.function.Function<? super T,MaybeT<W,B>> f) Flat Map the wrapped Maybe
<R1,R> MaybeT<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> MaybeT<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> MaybeT<W,R>	forEach2M(java.util.function.Function<? super T,? extends MaybeT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
<R1,R> MaybeT<W,R>	forEach2M(java.util.function.Function<? super T,? extends MaybeT<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> MaybeT<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> MaybeT<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> MaybeT<W,R>	forEach3M(java.util.function.Function<? super T,? extends MaybeT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MaybeT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
<T2,R1,R2,R> MaybeT<W,R>	forEach3M(java.util.function.Function<? super T,? extends MaybeT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MaybeT<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> MaybeT<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> MaybeT<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> MaybeT<W,R>	forEach4M(java.util.function.Function<? super T,? extends MaybeT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MaybeT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends MaybeT<W,R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
<T2,R1,R2,R3,R> MaybeT<W,R>	forEach4M(java.util.function.Function<? super T,? extends MaybeT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MaybeT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends MaybeT<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> MaybeT<W,A>	fromAnyM(AnyM<W,A> anyM) Construct an MaybeWT from an AnyM that contains a monad type that contains type other than Maybe The values in the underlying monad will be mapped to Maybe
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<MaybeT<W,U>,MaybeT<W,R>>	lift(java.util.function.Function<? super U,? extends R> fn) Lift a function into one that accepts and returns an MaybeWT This allows multiple monad types to add functionality to existing function and methods e.g.
static <W extends WitnessType<W>,U1,U2,R> java.util.function.BiFunction<MaybeT<W,U1>,MaybeT<W,U2>,MaybeT<W,R>>	lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn) Lift a BiFunction into one that accepts and returns MaybeWTs This allows multiple monad types to add functionality to existing function and methods e.g.
<B> MaybeT<W,B>	map(java.util.function.Function<? super T,? extends B> f) Map the wrapped Maybe
java.lang.String	mkString()
MaybeT<W,T>	notNull() Filter elements retaining only values which are not null
static <W extends WitnessType<W>,A> MaybeT<W,A>	of(AnyM<W,Maybe<A>> monads) Construct an MaybeWT from an AnyM that wraps a monad containing MaybeWs
<U> MaybeT<W,U>	ofType(java.lang.Class<? extends U> type) Keep only those elements in a reactiveStream that are of a given type.
MaybeT<W,T>	peek(java.util.function.Consumer<? super T> peek) Peek at the current value of the Maybe
ReactiveSeq<T>	stream()
java.lang.String	toString()
<R> MaybeT<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> MaybeT<W,R>	unit(R value)
protected <R> MaybeT<W,R>	unitAnyM(AnyM<W,? super MonadicValue<R>> traversable) Deprecated.
<R> MaybeT<W,R>	unitIterator(java.util.Iterator<R> it)
AnyM<W,Maybe<T>>	unwrap() Unwrap a wrapped value
<R> R	unwrapTo(java.util.function.Function<? super AnyM<W,Maybe<T>>,? extends R> fn)
MaybeT<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 SemigroupK and Monoids for a large number of canned combinations).
<T2,R> MaybeT<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> MaybeT<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> MaybeT<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> MaybeT<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> MaybeT<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> MaybeT<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> MaybeT<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> MaybeT<W,org.jooq.lambda.tuple.Tuple2<T,U>>	zipP(org.reactivestreams.Publisher<? extends U> other)
<U> MaybeT<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> MaybeT<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> MaybeT<W,R>	zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)
<R> MaybeT<W,R>	zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)
<R> MaybeT<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, unwrapNested

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

endsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleUnsafe, startsWith, startsWithIterable, takeOne, xMatch

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Methods inherited from interface cyclops.function.Fn0

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

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,Maybe<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,Maybe<T>>,? extends R> fn)

unitAnyM

@Deprecated
protected <R> MaybeT<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 MaybeT<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 - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

peek

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

Peek at the current value of the Maybe

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

Specified by:

peek in interface Transformable<T>

Parameters:

peek - Consumer to accept current value of Maybe

Returns:

MaybeWT with peek call

map

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

Map the wrapped Maybe

  
  MaybeWT.of(AnyM.fromStream(Arrays.asMaybeW(10))
             .map(t->t=t+1);
  
  
  //MaybeWT<AnyMSeq<Stream<Maybe[11]>>>
 
 

Specified by:

map in interface Transformable<T>

Parameters:

f - Mapping function for the wrapped Maybe

Returns:

MaybeWT that applies the map function to the wrapped Maybe

flatMapT

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

Flat Map the wrapped Maybe

  
  MaybeWT.of(AnyM.fromStream(Arrays.asMaybeW(10))
             .flatMap(t->Maybe.completedMaybe(20));
  
  
  //MaybeWT<AnyMSeq<Stream<Maybe[20]>>>
 
 

Parameters:

f - FlatMap function

Returns:

MaybeWT that applies the flatMap function to the wrapped Maybe

flatMap

public <B> MaybeT<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<MaybeT<W,U>,MaybeT<W,R>> lift(java.util.function.Function<? super U,? extends R> fn)

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

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

Parameters:

fn - Function to enhance with functionality from Maybe and another monad type

Returns:

Function that accepts and returns an MaybeWT

lift2

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

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

  
    	BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;
    	BiFunction<MaybeWT<Integer>,MaybeWT<Integer>,MaybeWT<Integer>> optTAdd2 = MaybeWT.lift2(add);
    	
    	Stream<Integer> withNulls = Stream.of(1,2,3);
    	AnyMSeq<Integer> reactiveStream = AnyM.ofMonad(withNulls);
    	AnyMSeq<Maybe<Integer>> streamOpt = reactiveStream.map(Maybe::completedMaybe);
    	
    	Maybe<Maybe<Integer>> two = Maybe.completedMaybe(Maybe.completedMaybe(2));
    	AnyMSeq<Maybe<Integer>> Maybe=  AnyM.fromMaybeW(two);
    	List<Integer> results = optTAdd2.applyHKT(MaybeWT.of(streamOpt),MaybeWT.of(Maybe))
    									.unwrap()
    									.<Stream<Maybe<Integer>>>unwrap()
    									.map(Maybe::join)
    									.collect(CyclopsCollectors.toList());
    									
    		//Maybe.completedMaybe(List[3,4,5]);
      
      

Parameters:

fn - BiFunction to enhance with functionality from Maybe and another monad type

Returns:

Function that accepts and returns an MaybeWT

fromAnyM

public static <W extends WitnessType<W>,A> MaybeT<W,A> fromAnyM(AnyM<W,A> anyM)

Construct an MaybeWT from an AnyM that contains a monad type that contains type other than Maybe The values in the underlying monad will be mapped to Maybe

Parameters:

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

Returns:

MaybeWT

of

public static <W extends WitnessType<W>,A> MaybeT<W,A> of(AnyM<W,Maybe<A>> monads)

Construct an MaybeWT from an AnyM that wraps a monad containing MaybeWs

Parameters:

monads - AnyM that contains a monad wrapping an Maybe

Returns:

MaybeWT

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

unitIterator

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

unit

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

Specified by:

unit in interface Unit<T>

empty

public <R> MaybeT<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> MaybeT<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 MaybeT<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 SemigroupK and Monoids for a large number of canned combinations). If this Applicative is a scalar value the provided value is combined with that value, otherwise the value is combined pair wise with all value in a non-scalar datastructure

Specified by:

zip in interface Zippable<T>

Overrides:

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

Returns:

See Also:

Semigroup, Semigroups, Monoid, To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in SemigroupK {@see com.aol.cyclops2.SemigroupK#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid) }

 {@code


  BinaryOperator> sumMaybes = SemigroupK.combineScalarFunctors(SemigroupK.intSum);
        Maybe.just(1).zip(sumMaybes, Maybe.just(5))
       //Maybe.just(6));
 }
 

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> MaybeT<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 - to zip with

fn - Zip function

Returns:

Combined zippable

zipP

public <T2,R> MaybeT<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 - to combine with

fn - Zip / combining function

Returns:

Combined zippable

zipS

public <U> MaybeT<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 to combine with

Returns:

Combined Zippable

zip

public <U> MaybeT<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 to combine with

Returns:

forEach4

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

forEach4M

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

forEach3M

public <T2,R1,R2,R> MaybeT<W,R> forEach3M(java.util.function.Function<? super T,? extends MaybeT<W,R1>> value1,
                                          java.util.function.BiFunction<? super T,? super R1,? extends MaybeT<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> MaybeT<W,R> forEach2M(java.util.function.Function<? super T,? extends MaybeT<W,R1>> value1,
                                    java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

forEach2M

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

zipper - Zip / combining function

Returns:

Combined zippable

zipP

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