AnyMValue (cyclops-reactor 9.0.0-FINAL API)

Type Parameters:

T - Data types of elements managed by wrapped scalar Monad.

All Superinterfaces:

AnyM<W,T>, Convertable<T>, ConvertableToReactiveSeq<T>, EmptyUnit<T>, Filters<T>, Fn0<T>, Folds<T>, java.lang.Iterable<T>, MonadicValue<T>, java.util.function.Predicate<T>, org.reactivestreams.Publisher<T>, java.util.function.Supplier<T>, To<AnyM<W,T>>, ToStream<T>, Transformable<T>, Unit<T>, Unwrapable, Value<T>, Visitable<T>, Zippable<T>

All Known Subinterfaces:

AnyMValue2<W,T2,T>

All Known Implementing Classes:

AnyMValue2Impl, AnyMValueImpl
```
public interface AnyMValue<W extends WitnessType<W>,T>
extends AnyM<W,T>, Value<T>, Filters<T>, MonadicValue<T>
```
Wrapper around 'Any' scalar 'M'onad

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.monads.AnyM
  AnyM.AnyMFactory
- Nested classes/interfaces inherited from interface com.aol.cyclops2.types.Value
  Value.ValueImpl<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops2.types.foldable.Convertable
  Convertable.SupplierToConvertable<T>
- Nested classes/interfaces inherited from interface cyclops.function.Fn0
  Fn0.FunctionalOperations<R>, Fn0.Instances, Fn0.SupplierKind<R>

Method Summary

All Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`default AnyMValue<W,java.util.List<T>>`	`aggregate(AnyM<W,T> next)` Aggregate the contents of this Monad and the supplied Monad
`default int`	`arity()`
`default <U> AnyMValue<W,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream to a given type, possibly throwing a `ClassCastException`.
`default <R> AnyMValue<W,R>`	`coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)` Perform a coflatMap operation.
`default <R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)` Collect the contents of the monad wrapped by this AnyM into supplied collector A mutable reduction operation equivalent to Stream#collect
`default <T2,R> AnyMValue<W,R>`	`combine(Value<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example
`default AnyMValue<W,T>`	`combineEager(Monoid<T> monoid, AnyMValue<W,? extends T> v2)`
`default AnyMValue<W,T>`	`combineEager(Monoid<T> monoid, MonadicValue<? extends T> v2)` Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e.
`default <T> AnyMValue<W,T>`	`empty()` Construct an AnyM wrapping a new zero instance of the wrapped type e.g.
`default <T> AnyMValue<W,T>`	`emptyUnit()`
`default boolean`	`eqv(AnyMValue<?,T> t)` Equivalence test, returns true if this Monad is equivalent to the supplied monad e.g.
`default AnyMValue<W,T>`	`filter(java.util.function.Predicate<? super T> p)` Perform a filter operation on the wrapped monad instance e.g.
`default AnyMValue<W,T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`default <R> AnyMValue<W,R>`	`flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> fn)` A flattening transformation operation (@see `Optional.flatMap(Function)`
`default <R> AnyMValue<W,R>`	`flatMapA(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)`
`default <R> AnyMValue<W,R>`	`flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)` A flattening transformation operation that takes the first value from the returned Iterable.
`default <R> AnyMValue<W,R>`	`flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)` A flattening transformation operation that takes the first value from the returned Publisher.
`default <R> AnyMValue<W,R>`	`flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)`
`default <R1,R> AnyMValue<W,R>`	`forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue
`default <R1,R> AnyMValue<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)` Perform a two level nested internal iteration over this MonadicValue and the supplied reactiveStream
`default <T2,R1,R2,R> AnyMValue<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)` Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
`default <T2,R1,R2,R> AnyMValue<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)` Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
`default <T2,R1,R2,R3,R> AnyMValue<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)` Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues
`default <T2,R1,R2,R3,R> AnyMValue<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)` Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues `Maybe.of(3) .forEach4(a->Maybe.just(a+10), (a,b)->Maybe.just(a+b), (a,b,c)->Maybe.none(), (a,b,c,d)->a+b+c<100, (a,b,c,d)->a+b+c+d); //Maybe.none`
`default T`	`get()`
`default boolean`	`isPresent()`
`default java.util.Iterator<T>`	`iterator()`
`default <R> AnyMValue<W,R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`default Xor<AnyMValue<W,T>,AnyMSeq<W,T>>`	`matchable()` Allows structural matching on the value / seq nature of this AnyM.
`default java.lang.String`	`mkString()` Returns the class name and the name of the subclass, if there is any value, the value is showed between square brackets.
`default AnyMValue<W,MonadicValue<T>>`	`nest()` cojoin pattern.
`default AnyMValue<W,T>`	`notNull()` Filter elements retaining only values which are not null
`default <U> AnyMValue<W,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a reactiveStream that are of a given type.
`default AnyMValue<W,T>`	`peek(java.util.function.Consumer<? super T> c)` Perform a peek operation on the wrapped monad e.g.
`default <R> AnyMValue<W,R>`	`retry(java.util.function.Function<? super T,? extends R> fn)` Retry a transformation if it fails.
`default <R> AnyMValue<W,R>`	`retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)` Retry a transformation if it fails.
`default ReactiveSeq<T>`	`stream()`
`default <R> AnyMValue<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
`default <T> AnyMValue<W,T>`	`unit(T value)` Construct a new instanceof AnyM using the type of the underlying wrapped monad
`default AnyMValue<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).
`default <T2,R> AnyMValue<W,R>`	`zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`default <S,U> AnyMValue<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
`default <S,U,R> AnyMValue<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)`
`default <T2,T3,T4> AnyMValue<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
`default <T2,T3,T4,R> AnyMValue<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)`
`default <T2,R> AnyMValue<W,R>`	`zipP(org.reactivestreams.Publisher<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`default <U> AnyMValue<W,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`default <R> AnyMValue<W,R>`	`zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)`
`default <R> AnyMValue<W,R>`	`zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)`
`default <R> AnyMValue<W,R>`	`zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)`

Methods inherited from interface cyclops.monads.AnyM
adapter, always, always, ap, ap2, coflatMapA, completableFutureOf, eqv, failure, flatten, flattenI, fromArray, fromBagX, fromCollectionX, fromCompletableFuture, fromDeque, fromDoubleStream, fromEither, fromEither3, fromEither4, fromEither5, fromEval, fromFuture, fromFutureStream, fromIdentity, fromIntStream, fromIor, fromIterable, fromLinkedListX, fromList, fromLongStream, fromMaybe, fromMonadicValue, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromOrderedSetX, fromPersistentQueueX, fromPersistentSetX, fromPublisher, fromQueue, fromSet, fromSortedSet, fromStream, fromStream, fromStream, fromStreamable, fromTry, fromVectorX, fromXor, futureOf, generate, identity, just, later, left, liftF, liftF2, liftF2, liftF3, liftF3, liftF4, liftF4, liftF5, liftF5, liftMFuture, liftMFuture, liftMList, liftMListX, listFromCompletableFuture, listFromEither, listFromEither3, listFromEither4, listFromEither5, listFromEval, listFromFuture, listFromIor, listFromMaybe, listFromOptional, listFromStream, listFromStreamable, listFromXor, listOf, maybeNullable, narrow, nestA, none, ofNullable, ofSeq, ofValue, ofValue, ofValue2, ofValue2, primary, rangeLongOf, rangeOf, reactiveSeq, right, secondary, sequence, sequence, streamOf, success, success, toString, traverse, traverse, unitIterator, zip, zipS, zipS

Methods inherited from interface com.aol.cyclops2.types.Unwrapable
unwrap, unwrapIfInstance, unwrapNested

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

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

Methods inherited from interface com.aol.cyclops2.types.Value
apply, generate, iterate, newSubscriber, of, subscribe, test, toEither, toEval, toEvalAlways, toEvalLater, toEvalNow, toIor, toLeft, toMaybe, toMaybeEager, toRight, toTry, toTry, toTry, toXor, toXor

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 com.aol.cyclops2.types.foldable.Convertable
fromSupplier, orElse, orElseGet, orElseThrow, toCompletableFuture, toCompletableFutureAsync, toFuture, toFutureAsync, toOptional, toStream, visit

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

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

Methods inherited from interface java.util.function.Predicate
and, isEqual, negate, or

- Method Detail
  - collect
```
default <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
```
    Description copied from interface: AnyM
    Collect the contents of the monad wrapped by this AnyM into supplied collector A mutable reduction operation equivalent to Stream#collect
```
 
      AnyM<Integer> monad1 = AnyM.fromStream(Stream.of(1,2,3));
      AnyM<Integer> monad2 = AnyM.fromOptional(Optional.of(1));

      List<Integer> list1 = monad1.collect(CyclopsCollectors.toList());
      List<Integer> list2 = monad2.collect(CyclopsCollectors.toList());

 
 
```
    Specified by:
    
    collect in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    collect in interface Convertable<T>
    
    Parameters:
    
    collector - JDK collector to perform mutable reduction
    
    Returns:
    
    Reduced value
  - eqv
```
default boolean eqv(AnyMValue<?,T> t)
```
    Equivalence test, returns true if this Monad is equivalent to the supplied monad e.g.
```
 {code
     Optional.of(1) and CompletableFuture.completedFuture(1) are equivalent
 }
 
```
    Parameters:
    
    t - Monad to compare to
    
    Returns:
    
    true if equivalent
  - zip
```
default AnyMValue<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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zip in interface Zippable<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)); }
  - arity
```
default int arity()
```
    Specified by:
    
    arity in interface MonadicValue<T>
  - coflatMap
```
default <R> AnyMValue<W,R> coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)
```
    Description copied from interface: MonadicValue
    Perform a coflatMap operation. The mapping function accepts this MonadicValue and returns a singleUnsafe value to be wrapped inside a Monad.
```
  
   Maybe.none().coflatMap(m -> m.isPresent() ? m.get() : 10);
   //Maybe[10]
 
 
```
    Specified by:
    
    coflatMap in interface MonadicValue<T>
    
    Parameters:
    
    mapper - Mapping / transformation function
    
    Returns:
    
    MonadicValue wrapping return value from transformation function applied to the value inside this MonadicValue
  - nest
```
default AnyMValue<W,MonadicValue<T>> nest()
```
    Description copied from interface: MonadicValue
    
    cojoin pattern. Nests this Monad inside another.
    
    Specified by:
    
    nest in interface MonadicValue<T>
    
    Returns:
    
    Nested Monad
  - combineEager
```
default AnyMValue<W,T> combineEager(Monoid<T> monoid,
                                    AnyMValue<W,? extends T> v2)
```
  - mkString
```
default java.lang.String mkString()
```
    Description copied from interface: Value
    
    Returns the class name and the name of the subclass, if there is any value, the value is showed between square brackets.
    
    Specified by:
    
    mkString in interface Value<T>
    
    Returns:
    
    String
  - zipWith
```
default <R> AnyMValue<W,R> zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)
```
    Specified by:
    
    zipWith in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zipWith in interface Zippable<T>
  - zipWithS
```
default <R> AnyMValue<W,R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)
```
    Specified by:
    
    zipWithS in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zipWithS in interface Zippable<T>
  - zipWithP
```
default <R> AnyMValue<W,R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)
```
    Specified by:
    
    zipWithP in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zipWithP in interface Zippable<T>
  - retry
```
default <R> AnyMValue<W,R> retry(java.util.function.Function<? super T,? extends R> fn)
```
    Description copied from interface: Transformable
    Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.
```
 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock)
 				.firstValue();

 		//result = 42
 
 
```
    Specified by:
    
    retry in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    retry in interface Transformable<T>
    
    Parameters:
    
    fn - Function to retry if fails
  - zipP
```
default <U> AnyMValue<W,org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)
```
    Specified by:
    
    zipP in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zipP in interface Zippable<T>
  - retry
```
default <R> AnyMValue<W,R> retry(java.util.function.Function<? super T,? extends R> fn,
                                 int retries,
                                 long delay,
                                 java.util.concurrent.TimeUnit timeUnit)
```
    Description copied from interface: Transformable
    Retry a transformation if it fails. Retries up to retries times, with an doubling backoff period starting @ delay TimeUnits delay before retry.
```
 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
 				.firstValue();

 		//result = 42
 
 
```
    Specified by:
    
    retry in interface AnyM<W extends WitnessType<W>,T>
    
    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
  - zip3
```
default <S,U> AnyMValue<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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zip3 in interface Zippable<T>
  - zip3
```
default <S,U,R> AnyMValue<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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zip3 in interface Zippable<T>
  - zip4
```
default <T2,T3,T4> AnyMValue<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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zip4 in interface Zippable<T>
  - zip4
```
default <T2,T3,T4,R> AnyMValue<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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zip4 in interface Zippable<T>
  - ofType
```
default <U> AnyMValue<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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    ofType in interface Filters<T>
  - filterNot
```
default AnyMValue<W,T> filterNot(java.util.function.Predicate<? super T> fn)
```
    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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    filterNot in interface Filters<T>
    
    Parameters:
    
    fn - to filter elements by, retaining matches
    
    Returns:
    
    Filters with elements removed where the predicate does not hold
  - notNull
```
default AnyMValue<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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    notNull in interface Filters<T>
    
    Returns:
    
    Filters with nulls removed
  - cast
```
default <U> AnyMValue<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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    cast in interface Transformable<T>
  - trampoline
```
default <R> AnyMValue<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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    trampoline in interface Transformable<T>
    
    Parameters:
    
    mapper - TCO Transformation function
    
    Returns:
    
    Transformable transformed by the supplied transformation function
  - emptyUnit
```
default <T> AnyMValue<W,T> emptyUnit()
```
    Specified by:
    
    emptyUnit in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    emptyUnit in interface EmptyUnit<T>
    
    Returns:
    
    A new, zero instance of this EmptyUnit type
  - filter
```
default AnyMValue<W,T> filter(java.util.function.Predicate<? super T> p)
```
    Description copied from interface: AnyM
    Perform a filter operation on the wrapped monad instance e.g.
```
 
   AnyM.fromOptional(Optional.of(10)).filter(i->i<10);
 
   //AnyM[Optional.zero()]
   
   AnyM.fromStream(Stream.of(5,10)).filter(i->i<10);
   
   //AnyM[Stream[5]]
 
 
 
 
```
    Specified by:
    
    filter in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    filter in interface Filters<T>
    
    Specified by:
    
    filter in interface MonadicValue<T>
    
    Parameters:
    
    p - Filtering predicate
    
    Returns:
    
    Filtered AnyM
  - map
```
default <R> AnyMValue<W,R> map(java.util.function.Function<? super T,? extends R> fn)
```
    Description copied from interface: Transformable
    Transform this functor using the supplied transformation function
```
 


    of(1,2,3).map(i->i*2)

    //[2,4,6]

 
 
```
    Specified by:
    
    map in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    map in interface MonadicValue<T>
    
    Specified by:
    
    map in interface Transformable<T>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Transformed Transformable
  - peek
```
default AnyMValue<W,T> peek(java.util.function.Consumer<? super T> c)
```
    Description copied from interface: AnyM
    Perform a peek operation on the wrapped monad e.g.
```
  
   AnyM.fromCompletableFuture(CompletableFuture.supplyAsync(()->loadData())
       .peek(System.out::println)
 
 
```
    Specified by:
    
    peek in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    peek in interface Transformable<T>
    
    Parameters:
    
    c - Consumer to accept current data
    
    Returns:
    
    AnyM after peek operation
  - isPresent
```
default boolean isPresent()
```
    Specified by:
    
    isPresent in interface Convertable<T>
    
    Returns:
    
    True if value exists and is non-null
  - aggregate
```
default AnyMValue<W,java.util.List<T>> aggregate(AnyM<W,T> next)
```
    Description copied from interface: AnyM
    Aggregate the contents of this Monad and the supplied Monad
```
 
 
 AnyM.fromStream(Stream.of(1,2,3,4))
 							.aggregate(fromEither5(Optional.of(5)))
 
 AnyM[Stream[List[1,2,3,4,5]]
 
 List<Integer> result = AnyM.fromStream(Stream.of(1,2,3,4))
 							.aggregate(fromEither5(Optional.of(5)))
 							.toSequence()
                          .flatten()
 							.toList();
    	
    	assertThat(result,equalTo(Arrays.asList(1,2,3,4,5)));
    	
```
    Specified by:
    
    aggregate in interface AnyM<W extends WitnessType<W>,T>
    
    Parameters:
    
    next - Monad to aggregate content with
    
    Returns:
    
    Aggregated Monad
  - flatMapA
```
default <R> AnyMValue<W,R> flatMapA(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)
```
    Specified by:
    
    flatMapA in interface AnyM<W extends WitnessType<W>,T>
  - flatMapI
```
default <R> AnyMValue<W,R> flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)
```
    Description copied from interface: MonadicValue
    A flattening transformation operation that takes the first value from the returned Iterable.
```
  
   Maybe.just(1).map(i->i+2).flatMapI(i->Arrays.asList(()->i*3,20);
   //Maybe[9]
 
 
```
    Specified by:
    
    flatMapI in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    flatMapI in interface MonadicValue<T>
    
    Parameters:
    
    fn - transformation function
    
    Returns:
    
    MonadicValue
  - flatMapP
```
default <R> AnyMValue<W,R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
    Description copied from interface: MonadicValue
    A flattening transformation operation that takes the first value from the returned Publisher.
```
  
   Future.ofResult(1).map(i->i+2).flatMapP(i->Flux.just(()->i*3,20);
   //Future[9]
 
 
```
    Specified by:
    
    flatMapP in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    flatMapP in interface MonadicValue<T>
    
    Parameters:
    
    fn - transformation function
    
    Returns:
    
    MonadicValue
  - flatMapS
```
default <R> AnyMValue<W,R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
```
    Specified by:
    
    flatMapS in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    flatMapS in interface MonadicValue<T>
  - flatMap
```
default <R> AnyMValue<W,R> flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> fn)
```
    Description copied from interface: MonadicValue
    A flattening transformation operation (@see Optional.flatMap(Function)
```
  
   Eval.now(1).map(i->i+2).flatMap(i->Eval.later(()->i*3);
   //Eval[9]
 
 
```
    Specified by:
    
    flatMap in interface MonadicValue<T>
    
    Parameters:
    
    fn - transformation function
    
    Returns:
    
    MonadicValue
  - get
```
default T get()
```
    Specified by:
    
    get in interface Convertable<T>
    
    Specified by:
    
    get in interface java.util.function.Supplier<T>
    
    Returns:
    
    Contained value, maybe null
  - unit
```
default <T> AnyMValue<W,T> unit(T value)
```
    Description copied from interface: AnyM
    Construct a new instanceof AnyM using the type of the underlying wrapped monad
```
 
   AnyM<Integer> ints = AnyM.fromList(Arrays.asList(1,2,3);
   AnyM<String> string = ints.unit("hello");
 
 
```
    Specified by:
    
    unit in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    unit in interface MonadicValue<T>
    
    Specified by:
    
    unit in interface Unit<T>
    
    Parameters:
    
    value - to embed inside the monad wrapped by AnyM
    
    Returns:
    
    Newly instantated AnyM
  - empty
```
default <T> AnyMValue<W,T> empty()
```
    Description copied from interface: AnyM
    Construct an AnyM wrapping a new zero instance of the wrapped type e.g.
```
  
 Any<Integer> ints = AnyM.fromStream(Stream.of(1,2,3));
 AnyM<Integer> zero=ints.zero();
 
 
```
    Specified by:
    
    empty in interface AnyM<W extends WitnessType<W>,T>
    
    Returns:
    
    Empty AnyM
  - matchable
```
default Xor<AnyMValue<W,T>,AnyMSeq<W,T>> matchable()
```
    Description copied from interface: AnyM
    Allows structural matching on the value / seq nature of this AnyM. If this AnyM can only store a singleUnsafe value an Xor.secondary with type AnyMValue is returned If this AnyM can store one or many values an Xor.primary with type AnyMSeq is returned
```
 
    AnyM<String> monad;
    
    monad.matchable().visit(v->handleValue(v.get()),s->handleSequence(s.toList()));
 
 
```
    Specified by:
    
    matchable in interface AnyM<W extends WitnessType<W>,T>
    
    Returns:
    
    An Xor for pattern matching lazy an AnyMValue or AnyMSeq
  - combine
```
default <T2,R> AnyMValue<W,R> combine(Value<? extends T2> app,
                                      java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
    Description copied from interface: MonadicValue
    Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example
```
 
   Maybe<Integer> some = Maybe.just(10);
   just.combine(Eval.now(20), this::add);
   //Some[30]

   Maybe<Integer> none = Maybe.none();
   none.combine(Eval.now(20), this::add);
   //None

 
 
```
    Specified by:
    
    combine in interface MonadicValue<T>
    
    Parameters:
    
    app - Value to combine with this one.
    
    fn - BiFunction to combine them
    
    Returns:
    
    New Applicativefunctor that represents the combined values
  - zip
```
default <T2,R> AnyMValue<W,R> zip(java.lang.Iterable<? extends T2> app,
                                  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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zip in interface MonadicValue<T>
    
    Specified by:
    
    zip in interface Zippable<T>
    
    Parameters:
    
    app - to zip with
    
    fn - Zip function
    
    Returns:
    
    Combined zippable
  - zipP
```
default <T2,R> AnyMValue<W,R> zipP(org.reactivestreams.Publisher<? extends T2> app,
                                   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 AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    zipP in interface MonadicValue<T>
    
    Specified by:
    
    zipP in interface Zippable<T>
    
    Parameters:
    
    app - to combine with
    
    fn - Zip / combining function
    
    Returns:
    
    Combined zippable
  - iterator
```
default java.util.Iterator<T> iterator()
```
    Specified by:
    
    iterator in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    iterator in interface Convertable<T>
    
    Specified by:
    
    iterator in interface java.lang.Iterable<T>
    
    Specified by:
    
    iterator in interface Value<T>
  - stream
```
default ReactiveSeq<T> stream()
```
    Specified by:
    
    stream in interface AnyM<W extends WitnessType<W>,T>
    
    Specified by:
    
    stream in interface Folds<T>
    
    Specified by:
    
    stream in interface ToStream<T>
    
    Specified by:
    
    stream in interface Value<T>
    
    Returns:
    
    ReactiveSeq from this Streamable
  - forEach4
```
default <T2,R1,R2,R3,R> AnyMValue<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)
```
    Description copied from interface: MonadicValue
    Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues
```
  
  Maybe.of(3)
       .forEach4(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->Maybe.none(),
                 (a,b,c,d)->a+b+c+d);
                                  
  
  //Maybe.none
 
 
```
    Specified by:
    
    forEach4 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested MonadicValue to iterate over
    
    value2 - Nested MonadicValue to iterate over
    
    value3 - Nested MonadicValue to iterate over
    
    yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - forEach4
```
default <T2,R1,R2,R3,R> AnyMValue<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)
```
    Description copied from interface: MonadicValue
    
    Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues Maybe.of(3) .forEach4(a->Maybe.just(a+10), (a,b)->Maybe.just(a+b), (a,b,c)->Maybe.none(), (a,b,c,d)->a+b+c<100, (a,b,c,d)->a+b+c+d); //Maybe.none
    
    Specified by:
    
    forEach4 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested MonadicValue to iterate over
    
    value2 - Nested MonadicValue to iterate over
    
    value3 - Nested MonadicValue to iterate over
    
    filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function
    
    yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - forEach3
```
default <T2,R1,R2,R> AnyMValue<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)
```
    Description copied from interface: MonadicValue
    Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
```
  
  Maybe.of(3)
       .forEach3(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->a+b+c<100,
                 (a,b,c)->a+b+c);
                                  
  
  //Maybe[32]
 
 
```
    Specified by:
    
    forEach3 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested MonadicValue to iterate over
    
    value2 - Nested MonadicValue to iterate over
    
    yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - forEach3
```
default <T2,R1,R2,R> AnyMValue<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)
```
    Description copied from interface: MonadicValue
    Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
```
  
  Maybe.of(3)
       .forEach3(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->a+b+c<100,
                 (a,b,c)->a+b+c);
                                  
  
  //Maybe[32]
 
 
```
    Specified by:
    
    forEach3 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested MonadicValue to iterate over
    
    value2 - Nested MonadicValue to iterate over
    
    filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function
    
    yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - forEach2
```
default <R1,R> AnyMValue<W,R> forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                       java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
    Description copied from interface: MonadicValue
    Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue
```
  
  Maybe.of(3)
       .forEach2(a->Maybe.none(),
                 (a,b)->a+b);
                                  
 
  //Maybe.none()
 
 
```
    Specified by:
    
    forEach2 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested Monadic Type to iterate over
    
    yieldingFunction - Function with pointers to the current element from both monad types that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - forEach2
```
default <R1,R> AnyMValue<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)
```
    Description copied from interface: MonadicValue
    Perform a two level nested internal iteration over this MonadicValue and the supplied reactiveStream
```
  
  Maybe.of(3)
       .forEach2(a->Maybe.none(),
                 a->b-> a<3 && b>10,
                 (a,b)->a+b);
                                  
 
  //Maybe.none()
 
 
```
    Specified by:
    
    forEach2 in interface MonadicValue<T>
    
    filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function
    
    yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - combineEager
```
default AnyMValue<W,T> combineEager(Monoid<T> monoid,
                                    MonadicValue<? extends T> v2)
```
    Description copied from interface: MonadicValue
    Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e. maybe / async alternatives)
```
  
 
  Monoid<Integer> add = Monoid.of(1,SemigroupK.intSum);
  Maybe.of(10).combineEager(add,Maybe.none());
  //Maybe[10]
  
  Maybe.none().combineEager(add,Maybe.of(10));
  //Maybe[10]
  
  Maybe.none().combineEager(add,Maybe.none());
  //Maybe.none()
  
  Maybe.of(10).combineEager(add,Maybe.of(10));
  //Maybe[20]
  
  Monoid<Integer> firstNonNull = Monoid.of(null , SemigroupK.firstNonNull());
  Maybe.of(10).combineEager(firstNonNull,Maybe.of(10));
  //Maybe[10]
 
```
    Specified by:
    
    combineEager in interface MonadicValue<T>
    
    Returns:

Interface AnyMValue<W extends WitnessType<W>,T>

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.monads.AnyM

Nested classes/interfaces inherited from interface com.aol.cyclops2.types.Value

Nested classes/interfaces inherited from interface com.aol.cyclops2.types.foldable.Convertable

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

Method Summary

Methods inherited from interface cyclops.monads.AnyM

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

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

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

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

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

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface cyclops.function.Fn0

Methods inherited from interface java.util.function.Predicate

Method Detail

collect

eqv

zip

arity

coflatMap

nest

combineEager

mkString

zipWith

zipWithS

zipWithP

retry

zipP

retry

zip3

zip3

zip4

zip4

ofType

filterNot

notNull

cast

trampoline

emptyUnit

filter

map

peek

isPresent

aggregate

flatMapA

flatMapI

flatMapP

flatMapS

flatMap

get

unit

empty

matchable

combine

zip

zipP

iterator

stream

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

combineEager