Maybe (cyclops-reactor 9.0.0-FINAL API)

Type Parameters:

T - Data type of element stored in Maybe

All Superinterfaces:

Convert<Higher<Witness.maybe,T>>, Convertable<T>, Filters<T>, Fn0<T>, Folds<T>, Higher<Witness.maybe,T>, java.lang.Iterable<T>, MonadicValue<T>, java.util.function.Predicate<T>, org.reactivestreams.Publisher<T>, Recoverable<T>, java.util.function.Supplier<T>, To<Maybe<T>>, Transformable<T>, Unit<T>, Value<T>, Visitable<T>, Zippable<T>

All Known Implementing Classes:

Maybe.CompletableMaybe, Maybe.Just, Maybe.Lazy, Maybe.Nothing
```
public interface Maybe<T>
extends To<Maybe<T>>, MonadicValue<T>, Recoverable<T>, Higher<Witness.maybe,T>
```
Totally lazy, reactiveBuffer more powerful general Option type. Maybe is maybe like a Java 8 Stream that represents 0 or 1 values rather than eager like a Java 8 Optional. map / peek/ filter and flatMap build the execution chaing, but are not executed until the value inside the Maybe is required. The Maybe interface has two implementations Some which holds a value and None which represents no value
```
  
    
    //eagerly load data
    Optional.of(10)
            .map(this::load);
    
    //lazily tee up loading of data until needed
    Maybe.of(10)
         .map(this::load);        
            .
 
 
 
```
Maybe is tail recursive
```
 {@code
```

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Maybe.CompletableMaybe<ORG,T2>`
`static class`	`Maybe.Instances` Companion class for creating Type Class instances for working with Maybes
`static class`	`Maybe.Just<T>`
`static class`	`Maybe.Lazy<T>`
`static class`	`Maybe.Nothing<T>`

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.SupplierKind<R>

Field Summary

Fields
Modifier and Type Field and Description

static Maybe EMPTY

Fields
Modifier and Type	Field and Description
`static Maybe`	`EMPTY`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T,R> Maybe<R>`	`accumulateJust(CollectionX<Maybe<T>> maybes, java.util.function.Function<? super T,R> mapper, Monoid<R> reducer)` Accumulate the results only from those Maybes which have a value present, using the supplied mapping function to convert the data from each Maybe before reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) `cyclops2.Monoids` ..
`static <T,R> Maybe<R>`	`accumulateJust(CollectionX<Maybe<T>> maybes, Reducer<R> reducer)` Accummulating operation using the supplied Reducer (@see cyclops2.Reducers).
`static <T> Maybe<T>`	`accumulateJust(Monoid<T> reducer, CollectionX<Maybe<T>> maybes)` Accumulate the results only from those Maybes which have a value present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) `cyclops2.Monoids` .
`default Active<Witness.maybe,T>`	`allTypeclasses()`
`default AnyM<Witness.maybe,T>`	`anyM()`
`static <T,R> java.util.function.Function<? super T,? extends Maybe<R>>`	`arrow(java.util.function.Function<? super T,? extends R> fn)`
`static <T> Maybe<T>`	`async(java.util.concurrent.Executor ex, java.util.function.Supplier<T> s)`
`default <U> Maybe<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream to a given type, possibly throwing a `ClassCastException`.
`default <R> Maybe<R>`	`coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)` Perform a coflatMap operation.
`default <T2,R> Maybe<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 Maybe<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 <W1> Coproduct<W1,Witness.maybe,T>`	`coproduct(InstanceDefinitions<W1> def2)`
`Maybe<T>`	`filter(java.util.function.Predicate<? super T> fn)` Keep only elements for which the supplied predicates hold e.g.
`default Maybe<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R> Maybe<R>`	`flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> mapper)` A flattening transformation operation (@see `Optional.flatMap(Function)`
`default <R> Maybe<R>`	`flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)` A flattening transformation operation that takes the first value from the returned Iterable.
`default <R> Maybe<R>`	`flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)` A flattening transformation operation that takes the first value from the returned Publisher.
`default <R> Maybe<R>`	`flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> mapper)`
`default <R1,R> Maybe<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> Maybe<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> Maybe<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> Maybe<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> Maybe<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> Maybe<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`
`static <T> Maybe<T>`	`fromEval(Eval<T> eval)` Construct a Maybe from the supplied Eval
`static <T> Maybe<T>`	`fromEvalNullable(Eval<T> eval)`
`static <T> Maybe<T>`	`fromEvalOf(Eval<T> eval)` Deprecated.
`static <T> Maybe<T>`	`fromEvalOptional(Eval<java.util.Optional<T>> value)`
`static <T> Maybe<T>`	`fromFuture(Future<T> future)`
`static <T> Maybe<T>`	`fromIterable(java.lang.Iterable<T> iterable)` Construct a Maybe that contains a singleUnsafe value extracted from the supplied Iterable
`static <T> Maybe<T>`	`fromLazy(Eval<Maybe<T>> lazy)`
`static <T> Maybe<T>`	`fromOptional(Higher<Witness.optional,T> optional)` Construct an equivalent Maybe from the Supplied Optional
`static <T> Maybe<T>`	`fromOptional(java.util.Optional<T> opt)` Construct an equivalent Maybe from the Supplied Optional
`static <T> Maybe<T>`	`fromOptionalKind(Optionals.OptionalKind<T> opt)`
`static <T> Maybe<T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub)` Construct a Maybe that contains a singleUnsafe value extracted from the supplied reactiveBuffer-streams Publisher
`static <R> Maybe<R>`	`fromStream(java.util.stream.Stream<? extends R> apply)`
`boolean`	`isPresent()`
`static <T> Maybe<T>`	`just(T value)` Construct an Maybe which contains the provided (non-null) value.
`static <T> Cokleisli<Witness.maybe,T,Maybe<T>>`	`kindCokleisli()`
`static <T> Kleisli<Witness.maybe,Maybe<T>,T>`	`kindKleisli()`
`default <W extends WitnessType<W>> MaybeT<W,T>`	`liftM(W witness)`
`<R> Maybe<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)` Transform this functor using the supplied transformation function
`default <W2,R> Nested<Witness.maybe,W2,R>`	`mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs)`
`static <T> Maybe.CompletableMaybe<T,T>`	`maybe()` Create a reactiveBuffer CompletableMaybe
`static <T> Maybe<T>`	`narrow(Maybe<? extends T> broad)` Narrow covariant type parameter
`static <T> Maybe<T>`	`narrowK(Higher<Witness.maybe,T> future)` Convert the raw Higher Kinded Type for MaybeType types into the MaybeType type definition class
`static <T> java.util.Optional<T>`	`narrowOptional(Higher<Witness.maybe,T> maybe)` Convert the HigherKindedType definition for a Maybe into
`default Maybe<MonadicValue<T>>`	`nest()` cojoin pattern.
`static <W1,T> Nested<Witness.maybe,W1,T>`	`nested(Maybe<Higher<W1,T>> nested, InstanceDefinitions<W1> def2)`
`static <T> Maybe<T>`	`none()`
`default Maybe<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> Maybe<T>`	`of(T value)` Construct an Maybe which contains the provided (non-null) value Equivalent to @see `just(Object)`
`static <T> Maybe<T>`	`ofNullable(T value)` `Maybe<Integer> maybe = Maybe.ofNullable(null); //None Maybe<Integer> maybe = Maybe.ofNullable(10); //Maybe[10], Some[10]`
`default <U> Maybe<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a reactiveStream that are of a given type.
`default Maybe<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`default <W1> Product<Witness.maybe,W1,T>`	`product(Active<W1,T> active)`
`Maybe<T>`	`recover(java.util.function.Supplier<? extends T> value)`
`Maybe<T>`	`recover(T value)`
`Maybe<T>`	`recoverWith(java.util.function.Supplier<? extends Maybe<T>> fn)`
`default <R> Maybe<R>`	`retry(java.util.function.Function<? super T,? extends R> fn)` Retry a transformation if it fails.
`default <R> Maybe<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.
`static <T> Maybe<ListX<T>>`	`sequence(CollectionX<Maybe<T>> maybes)` Sequence operation, take a Collection of Maybes and turn it into a Maybe with a Collection By constrast with `sequenceJust(CollectionX)` if any Maybe types are None / zero the return type will be an zero Maybe / None
`static <T> Maybe<ReactiveSeq<T>>`	`sequence(java.util.stream.Stream<Maybe<T>> maybes)` Sequence operation, take a Stream of Maybes and turn it into a Maybe with a Stream By constrast with `sequenceJust(CollectionX)` Maybe#zero/ None types are result in the returned Maybe being Maybe.zero / None
`static <T> Maybe<ListX<T>>`	`sequenceJust(CollectionX<Maybe<T>> maybes)` Sequence operation, take a Collection of Maybes and turn it into a Maybe with a Collection Only successes are retained.
`default Maybe<T>`	`toMaybe()`
`default Trampoline<Maybe<T>>`	`toTrampoline()`
`default <R> Maybe<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> Maybe<T>`	`unit(T unit)`
`<R> R`	`visit(java.util.function.Function<? super T,? extends R> some, java.util.function.Supplier<? extends R> none)` The provided function is executed with the value stored in this Visitable if one is present, otherwise the provided Supplier is executed instead.
`static <T> Higher<Witness.maybe,T>`	`widen(Maybe<T> narrow)`
`static <C2,T> Higher<C2,Higher<Witness.maybe,T>>`	`widen2(Higher<C2,Maybe<T>> nestedMaybe)`
`default Maybe<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> Maybe<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 <U> Maybe<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
`default <S,U> Maybe<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> Maybe<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> Maybe<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> Maybe<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> Maybe<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> Maybe<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`default <U> Maybe<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
`default <U,R> Maybe<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
`default <R> Maybe<R>`	`zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)`
`default <R> Maybe<R>`	`zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)`
`default <R> Maybe<R>`	`zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)`

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

Methods inherited from interface com.aol.cyclops2.types.MonadicValue
arity

Methods inherited from interface com.aol.cyclops2.types.Value
apply, generate, iterate, iterator, mkString, newSubscriber, stream, subscribe, test, toEither, toEval, toEvalAlways, toEvalLater, toEvalNow, toIor, toLeft, 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
collect, fromSupplier, get, orElse, orElseGet, orElseThrow, toCompletableFuture, toCompletableFutureAsync, toFuture, toFutureAsync, toOptional, toStream

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

Methods inherited from interface com.aol.cyclops2.hkt.Higher
applyHKT_, applyHKT, applyHKT

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

Field Detail
- EMPTY
```
static final Maybe EMPTY
```

Method Detail

kindKleisli

static <T> Kleisli<Witness.maybe,Maybe<T>,T> kindKleisli()

widen

static <T> Higher<Witness.maybe,T> widen(Maybe<T> narrow)

kindCokleisli

static <T> Cokleisli<Witness.maybe,T,Maybe<T>> kindCokleisli()

nested

static <W1,T> Nested<Witness.maybe,W1,T> nested(Maybe<Higher<W1,T>> nested,
                                                InstanceDefinitions<W1> def2)

product

default <W1> Product<Witness.maybe,W1,T> product(Active<W1,T> active)

coproduct

default <W1> Coproduct<W1,Witness.maybe,T> coproduct(InstanceDefinitions<W1> def2)

allTypeclasses

default Active<Witness.maybe,T> allTypeclasses()

mapM

default <W2,R> Nested<Witness.maybe,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn,
                                               InstanceDefinitions<W2> defs)

liftM

default <W extends WitnessType<W>> MaybeT<W,T> liftM(W witness)

async

static <T> Maybe<T> async(java.util.concurrent.Executor ex,
                          java.util.function.Supplier<T> s)

anyM
```
default AnyM<Witness.maybe,T> anyM()
```

fromLazy

static <T> Maybe<T> fromLazy(Eval<Maybe<T>> lazy)

maybe

static <T> Maybe.CompletableMaybe<T,T> maybe()

Create a reactiveBuffer CompletableMaybe

     
     CompletableMaybe<Integer,Integer> completable = Maybe.maybe();
           Maybe<Integer> mapped = completable.map(i->i*2)
                                              .flatMap(i->Eval.later(()->i+1));

            completable.complete(5);
            mapped.printOut();
            //11

            CompletableMaybe<Integer,Integer> completable = Maybe.maybe();
            Maybe<Integer> mapped = completable.map(i->i*2)
                                                .flatMap(i->Eval.later(()->i+1));

            completable.complete(null);
            mapped.printOut();
            //
            //Maybe:None

Type Parameters:: T - Data input type to the Maybe
Returns:: A reactiveBuffer CompletableMaybe

fromFuture

static <T> Maybe<T> fromFuture(Future<T> future)

arrow

static <T,R> java.util.function.Function<? super T,? extends Maybe<R>> arrow(java.util.function.Function<? super T,? extends R> fn)

fromOptional

static <T> Maybe<T> fromOptional(Higher<Witness.optional,T> optional)

Construct an equivalent Maybe from the Supplied Optional

 
   MaybeType<Integer> some = MaybeType.fromOptional(Optional.of(10));
   //Maybe[10], Some[10]

   MaybeType<Integer> none = MaybeType.fromOptional(Optional.zero());
   //Maybe.zero, None[]

Parameters:: opt - Optional to construct Maybe from
Returns:: Maybe created from Optional

widen2

static <C2,T> Higher<C2,Higher<Witness.maybe,T>> widen2(Higher<C2,Maybe<T>> nestedMaybe)

narrowK
```
static <T> Maybe<T> narrowK(Higher<Witness.maybe,T> future)
```
Convert the raw Higher Kinded Type for MaybeType types into the MaybeType type definition class

Parameters:

future - HKT encoded list into a MaybeType

Returns:

MaybeType

narrowOptional
```
static <T> java.util.Optional<T> narrowOptional(Higher<Witness.maybe,T> maybe)
```
Convert the HigherKindedType definition for a Maybe into

Parameters:

MaybeType - Constructor to convert back into narrowed type

Returns:

Optional from Higher Kinded Type

none
```
static <T> Maybe<T> none()
```
Returns:

Get the zero Maybe (singleUnsafe instance)

flatMapI
```
default <R> Maybe<R> flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
```
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 MonadicValue<T>

Parameters:

mapper - transformation function

Returns:

MonadicValue

flatMapP
```
default <R> Maybe<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
```
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 MonadicValue<T>

Parameters:

mapper - transformation function

Returns:

MonadicValue

fromPublisher
```
static <T> Maybe<T> fromPublisher(org.reactivestreams.Publisher<T> pub)
```
Construct a Maybe that contains a singleUnsafe value extracted from the supplied reactiveBuffer-streams Publisher
```
 
   ReactiveSeq<Integer> reactiveStream =  ReactiveSeq.of(1,2,3);

        Maybe<Integer> maybe = Maybe.fromPublisher(reactiveStream);

        //Maybe[1]

 
 
```
Parameters:

pub - Publisher to extract value from

Returns:

Maybe populated with first value from Publisher (Maybe.zero if Publisher zero)

fromIterable

static <T> Maybe<T> fromIterable(java.lang.Iterable<T> iterable)

Construct a Maybe that contains a singleUnsafe value extracted from the supplied Iterable

 
   ReactiveSeq<Integer> reactiveStream =  ReactiveSeq.of(1,2,3);

        Maybe<Integer> maybe = Maybe.fromIterable(reactiveStream);

        //Maybe[1]

Parameters:: iterable - Iterable to extract value from
Returns:: Maybe populated with first value from Iterable (Maybe.zero if Publisher zero)

fromStream

static <R> Maybe<R> fromStream(java.util.stream.Stream<? extends R> apply)

fromOptional

static <T> Maybe<T> fromOptional(java.util.Optional<T> opt)

Construct an equivalent Maybe from the Supplied Optional

 
   Maybe<Integer> some = Maybe.fromOptional(Optional.of(10));
   //Maybe[10], Some[10]

   Maybe<Integer> none = Maybe.fromOptional(Optional.zero());
   //Maybe.zero, None[]

Parameters:: opt - Optional to construct Maybe from
Returns:: Maybe created from Optional

fromOptionalKind

static <T> Maybe<T> fromOptionalKind(Optionals.OptionalKind<T> opt)

fromEvalOf

@Deprecated
static <T> Maybe<T> fromEvalOf(Eval<T> eval)

Deprecated.

toTrampoline

default Trampoline<Maybe<T>> toTrampoline()

fromEval

static <T> Maybe<T> fromEval(Eval<T> eval)

Construct a Maybe from the supplied Eval

 
     Maybe<Integer> maybe =  Maybe.fromEval(Eval.now(10));
     //Maybe[10]

Parameters:: eval - Eval to construct Maybe from
Returns:: Maybe created from Eval

fromEvalNullable

static <T> Maybe<T> fromEvalNullable(Eval<T> eval)

fromEvalOptional

static <T> Maybe<T> fromEvalOptional(Eval<java.util.Optional<T>> value)

just
```
static <T> Maybe<T> just(T value)
```
Construct an Maybe which contains the provided (non-null) value. Alias for @see of(Object)
```
 

    Maybe<Integer> some = Maybe.just(10);
    some.map(i->i*2);
 
 
```
Parameters:

value - Value to wrap inside a Maybe

Returns:

Maybe containing the supplied value

of
```
static <T> Maybe<T> of(T value)
```
Construct an Maybe which contains the provided (non-null) value Equivalent to @see just(Object)
```
 

    Maybe<Integer> some = Maybe.of(10);
    some.map(i->i*2);
 
 
```
Specified by:

of in interface Value<T>

Parameters:

value - Value to wrap inside a Maybe

Returns:

Maybe containing the supplied value

ofNullable

static <T> Maybe<T> ofNullable(T value)

 
    Maybe<Integer> maybe  = Maybe.ofNullable(null);
    //None

    Maybe<Integer> maybe = Maybe.ofNullable(10);
    //Maybe[10], Some[10]

Parameters:: value -
Returns:

narrow
```
static <T> Maybe<T> narrow(Maybe<? extends T> broad)
```
Narrow covariant type parameter

Parameters:

broad - Maybe with covariant type parameter

Returns:

Narrowed Maybe

sequenceJust

static <T> Maybe<ListX<T>> sequenceJust(CollectionX<Maybe<T>> maybes)

Sequence operation, take a Collection of Maybes and turn it into a Maybe with a Collection Only successes are retained. By constrast with sequence(CollectionX) Maybe#zero/ None types are tolerated and ignored.

 
  Maybe<Integer> just = Maybe.of(10);
        Maybe<Integer> none = Maybe.none();

 Maybe<ListX<Integer>> maybes = Maybe.sequenceJust(ListX.of(just, none, Maybe.of(1)));
       //Maybe.of(ListX.of(10, 1));

Parameters:: maybes - Maybes to Sequence
Returns:: Maybe with a List of values

sequence
```
static <T> Maybe<ListX<T>> sequence(CollectionX<Maybe<T>> maybes)
```
Sequence operation, take a Collection of Maybes and turn it into a Maybe with a Collection By constrast with sequenceJust(CollectionX) if any Maybe types are None / zero the return type will be an zero Maybe / None
```
 

  Maybe<Integer> just = Maybe.of(10);
        Maybe<Integer> none = Maybe.none();

  Maybe<ListX<Integer>> maybes = Maybe.sequence(ListX.of(just, none, Maybe.of(1)));
        //Maybe.none();

 
 
```
Parameters:

maybes - Maybes to Sequence

Returns:

Maybe with a List of values

sequence

static <T> Maybe<ReactiveSeq<T>> sequence(java.util.stream.Stream<Maybe<T>> maybes)

Sequence operation, take a Stream of Maybes and turn it into a Maybe with a Stream By constrast with sequenceJust(CollectionX) Maybe#zero/ None types are result in the returned Maybe being Maybe.zero / None

 

  Maybe<Integer> just = Maybe.of(10);
        Maybe<Integer> none = Maybe.none();

  Maybe<ReactiveSeq<Integer>> maybes = Maybe.sequence(Stream.of(just, none, Maybe.of(1)));
        //Maybe.none();

Parameters:: maybes - Maybes to Sequence
Returns:: Maybe with a Stream of values

accumulateJust

static <T,R> Maybe<R> accumulateJust(CollectionX<Maybe<T>> maybes,
                                     Reducer<R> reducer)

Accummulating operation using the supplied Reducer (@see cyclops2.Reducers). A typical use case is to accumulate into a Persistent Collection type. Accumulates the present results, ignores zero Maybes.

 
  Maybe<Integer> just = Maybe.of(10);
        Maybe<Integer> none = Maybe.none();
 Maybe<PersistentSetX<Integer>> maybes = Maybe.accumulateJust(ListX.of(just, none, Maybe.of(1)), Reducers.toPersistentSetX());
       //Maybe.of(PersistentSetX.of(10, 1)));

Parameters:: maybes - Maybes to accumulate; reducer - Reducer to accumulate values with
Returns:: Maybe with reduced value

accumulateJust

static <T,R> Maybe<R> accumulateJust(CollectionX<Maybe<T>> maybes,
                                     java.util.function.Function<? super T,R> mapper,
                                     Monoid<R> reducer)

Accumulate the results only from those Maybes which have a value present, using the supplied mapping function to convert the data from each Maybe before reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids ..

 
  Maybe<Integer> just = Maybe.of(10);
        Maybe<Integer> none = Maybe.none();

  Maybe<String> maybes = Maybe.accumulateJust(ListX.of(just, none, Maybe.of(1)), i -> "" + i,
                                                     SemigroupK.stringConcat);
        //Maybe.of("101")

Parameters:: maybes - Maybes to accumulate; mapper - Mapping function to be applied to the result of each Maybe; reducer - Monoid to combine values from each Maybe
Returns:: Maybe with reduced value

accumulateJust
```
static <T> Maybe<T> accumulateJust(Monoid<T> reducer,
                                   CollectionX<Maybe<T>> maybes)
```
Accumulate the results only from those Maybes which have a value present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids .
```
 

  Maybe<Integer> maybes = Maybe.accumulateJust(Monoids.intSum,ListX.of(just, none, Maybe.of(1)));
        //Maybe.of(11)

 
 
```
Parameters:

maybes - Maybes to accumulate

reducer - Monoid to combine values from each Maybe

Returns:

Maybe with reduced value

zipWith

default <R> Maybe<R> zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)

Specified by:: zipWith in interface Zippable<T>

zipWithS

default <R> Maybe<R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)

Specified by:: zipWithS in interface Zippable<T>

zipWithP

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

Specified by:: zipWithP in interface Zippable<T>

retry

default <R> Maybe<R> retry(java.util.function.Function<? super T,? extends R> fn)

Description copied from interface: Transformable

Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


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

 		//result = 42

Specified by:: retry in interface Transformable<T>
Parameters:: fn - Function to retry if fails

zipP

default <U> Maybe<org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)

Specified by:: zipP in interface Zippable<T>

retry

default <R> Maybe<R> retry(java.util.function.Function<? super T,? extends R> fn,
                           int retries,
                           long delay,
                           java.util.concurrent.TimeUnit timeUnit)

Description copied from interface: Transformable

Retry a transformation if it fails. Retries up to retries times, with an doubling backoff period starting @ delay TimeUnits delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


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

 		//result = 42

Specified by:: retry in interface Transformable<T>
Parameters:: fn - Function to retry if fails; retries - Number of retries; delay - Delay in TimeUnits; timeUnit - TimeUnit to use for delay

zip3

default <S,U> Maybe<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

default <S,U,R> Maybe<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

default <T2,T3,T4> Maybe<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

default <T2,T3,T4,R> Maybe<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>

flatMapS

default <R> Maybe<R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> mapper)

Specified by:: flatMapS in interface MonadicValue<T>

forEach4

default <T2,R1,R2,R3,R> Maybe<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> Maybe<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> Maybe<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> Maybe<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> Maybe<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> Maybe<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

combine

default <T2,R> Maybe<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> Maybe<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 MonadicValue<T>

Specified by:

zip in interface Zippable<T>

Parameters:

app - to zip with

fn - Zip function

Returns:

Combined zippable

zipP
```
default <T2,R> Maybe<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 MonadicValue<T>

Specified by:

zipP in interface Zippable<T>

Parameters:

app - to combine with

fn - Zip / combining function

Returns:

Combined zippable

zip
```
default Maybe<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>

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)); }

zipS
```
default <U,R> Maybe<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

zipS
```
default <U> Maybe<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>

Parameters:

other - Stream to combine with

Returns:

Combined Zippable

zip
```
default <U> Maybe<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>

Parameters:

other - Iterable to combine with

Returns:

unit
```
default <T> Maybe<T> unit(T unit)
```
Specified by:

unit in interface MonadicValue<T>

Specified by:

unit in interface Unit<T>

coflatMap
```
default <R> Maybe<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 Maybe<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 Maybe<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:

toMaybe
```
default Maybe<T> toMaybe()
```
Specified by:

toMaybe in interface Value<T>

isPresent
```
boolean isPresent()
```
Specified by:

isPresent in interface Convertable<T>

Returns:

True if value exists and is non-null

recover

Maybe<T> recover(java.util.function.Supplier<? extends T> value)

Specified by:: recover in interface Recoverable<T>

recover
```
Maybe<T> recover(T value)
```

recoverWith

Maybe<T> recoverWith(java.util.function.Supplier<? extends Maybe<T>> fn)

map
```
<R> Maybe<R> map(java.util.function.Function<? super T,? extends R> mapper)
```
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 MonadicValue<T>

Specified by:

map in interface Transformable<T>

Parameters:

mapper - Transformation function

Returns:

Transformed Transformable

flatMap
```
<R> Maybe<R> flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> mapper)
```
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:

mapper - transformation function

Returns:

MonadicValue

visit
```
<R> R visit(java.util.function.Function<? super T,? extends R> some,
            java.util.function.Supplier<? extends R> none)
```
Description copied from interface: Visitable

The provided function is executed with the value stored in this Visitable if one is present, otherwise the provided Supplier is executed instead.

Specified by:

visit in interface Convertable<T>

Specified by:

visit in interface Visitable<T>

Parameters:

some - Function to execute if this Visitable has a value

none - Supplier to execute if this Visitable does not have a Value

Returns:

Result of the executed Function or Supplier

filter
```
Maybe<T> filter(java.util.function.Predicate<? super T> fn)
```
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>

Specified by:

filter in interface MonadicValue<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

ofType

default <U> Maybe<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
```
default Maybe<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 Filters<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

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

notNull in interface Filters<T>

Returns:

Filters with nulls removed

cast
```
default <U> Maybe<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>

peek
```
default Maybe<T> peek(java.util.function.Consumer<? super T> c)
```
Description copied from interface: Transformable
Peek at the current value of this Transformable, without transforming it
```
 


    of(1,2,3).map(System.out::println)

    1
    2
    3

 
 
```
Specified by:

peek in interface Transformable<T>

Parameters:

c - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

trampoline

default <R> Maybe<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

Interface Maybe<T>

Nested Class Summary

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

Field Summary

Method Summary

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

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

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

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

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

Field Detail

EMPTY

Method Detail

kindKleisli

widen

kindCokleisli

nested

product

coproduct

allTypeclasses

mapM

liftM

async

anyM

fromLazy

maybe

fromFuture

arrow

fromOptional

widen2

narrowK

narrowOptional

none

flatMapI

flatMapP

fromPublisher

fromIterable

fromStream

fromOptional

fromOptionalKind

fromEvalOf

toTrampoline

fromEval

fromEvalNullable

fromEvalOptional

just

of

ofNullable

narrow

sequenceJust

sequence

sequence

accumulateJust

accumulateJust

accumulateJust

zipWith

zipWithS

zipWithP

retry

zipP

retry

zip3

zip3

zip4

zip4

flatMapS

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

combine