Option (cyclops 10.0.0-RC1 API)

All Superinterfaces:

Convert<Higher<DataWitness.option,T>>, EmptyUnit<T>, Filters<T>, Higher<DataWitness.option,T>, io.kindedj.Hk<DataWitness.option,T>, java.lang.Iterable<T>, MonadicValue<T>, OrElseValue<T,Option<T>>, org.reactivestreams.Publisher<T>, Recoverable<T>, Sealed2<T,Option.None<T>>, SealedOr<T>, java.io.Serializable, To<Option<T>>, Transformable<T>, Unit<T>, Value<T>, Zippable<T>

All Known Subinterfaces:

Maybe<T>

All Known Implementing Classes:

Maybe.CompletableMaybe, Maybe.Just, Maybe.Lazy, Maybe.Nothing, Option.None, Option.Some
```
public interface Option<T>
extends To<Option<T>>, OrElseValue<T,Option<T>>, MonadicValue<T>, Zippable<T>, Recoverable<T>, Sealed2<T,Option.None<T>>, java.lang.Iterable<T>, Higher<DataWitness.option,T>, java.io.Serializable
```
A safe replacement for Optional. Option consists of two states
```
  1. Some : a value is present
  2. None : no value is present
 
```
Unlike Optional, Option does not expose an unsafe `get` method. `fold` or `orElse` can be used instead.
See Also:

is a lazy / reactive sub-class of Option

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Option.Comprehensions

static class Option.None<T>

static class Option.Some<T>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Option.Comprehensions`
`static class`	`Option.None<T>`
`static class`	`Option.Some<T>`

Field Summary

Fields
Modifier and Type Field and Description

static Option EMPTY

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

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`static <T,R> Option<R>`	`accumulateJust(java.lang.Iterable<Option<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> Option<R>`	`accumulateJust(java.lang.Iterable<Option<T>> maybes, Reducer<R,T> reducer)` Accummulating operation using the supplied Reducer (@see cyclops2.Reducers).
`static <T> Option<T>`	`accumulateJust(Monoid<T> reducer, java.lang.Iterable<Option<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) `cyclops.Monoids` .
`static <T> Option<T>`	`attempt(CheckedSupplier<T> s)`
`default <R> Option<R>`	`attemptFlatMap(java.util.function.Function<? super T,? extends Option<? extends R>> fn)`
`default <R> Option<R>`	`concatMap(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 Option<T>`	`eager()`
`default <T1> Option<T1>`	`emptyUnit()`
`Option<T>`	`filter(java.util.function.Predicate<? super T> fn)` Keep only elements for which the supplied predicates hold e.g.
`default Option<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R> Option<R>`	`flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> mapper)` A flattening transformation operation (@see `Optional.flatMap(Function)`
`<R> R`	`fold(java.util.function.Function<? super T,? extends R> some, java.util.function.Supplier<? extends R> none)`
`default <R1,R> Option<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> Option<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 stream
`default <T2,R1,R2,R> Option<R>`	`forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Function3<? 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> Option<R>`	`forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Function3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Function3<? 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> Option<R>`	`forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Function3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Function4<? 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> Option<R>`	`forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Function3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Function4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Function4<? 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> Option<T>`	`fromFuture(Future<T> future)`
`static <T> Option<T>`	`fromIterable(java.lang.Iterable<T> iterable)` Construct an Option that contains a single value extracted from the supplied Iterable
`static <T> Option<T>`	`fromNullable(T t)`
`static <T> Option<T>`	`fromOptional(java.util.Optional<T> opt)` Construct an equivalent Option from the Supplied Optional
`static <T> Option<T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub)` Construct a Maybe that contains a single value extracted from the supplied reactive-streams Publisher
`static <R> Option<R>`	`fromStream(java.util.stream.Stream<R> apply)`
`boolean`	`isPresent()`
`default Maybe<T>`	`lazy()`
`<R> Option<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)` Transform this functor using the supplied transformation function
`default <R> Option<R>`	`mergeMap(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.
`static <T> Option<T>`	`narrow(Option<? extends T> broad)` Narrow covariant type parameter
`static <T> Option<T>`	`narrowK(Higher<DataWitness.option,T> opt)`
`static <T> Option<T>`	`none()`
`default Option<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> Option<T>`	`of(T value)` Construct an Option which contains the provided (non-null) value Equivalent to @see `some(Object)`
`static <T> Option<T>`	`ofNullable(T value)` `Option<Integer> maybe = Option.ofNullable(null); //None Option<Integer> maybe = Option.ofNullable(10); //Option[10], Some[10]`
`default <U> Option<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default Option<T>`	`orElseUse(Option<T> opt)`
`default Option<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`Option<T>`	`recover(java.util.function.Supplier<? extends T> value)`
`Option<T>`	`recover(T value)`
`Option<T>`	`recoverWith(java.util.function.Supplier<? extends Option<T>> fn)`
`static <T> Option<ReactiveSeq<T>>`	`sequence(java.lang.Iterable<? extends Option<T>> maybes)` Sequence operation, take a Collection of Options and turn it into a Option with a Collection By constrast with `sequenceJust(Iterable)` if any Option types are None / zero the return type will be an zero Option / None
`static <T> Option<ReactiveSeq<T>>`	`sequence(ReactiveSeq<? extends Option<T>> stream)`
`static <T> Option<ReactiveSeq<T>>`	`sequence(java.util.stream.Stream<? extends Option<T>> maybes)` Sequence operation, take a Stream of Option and turn it into a Option with a Stream By constrast with `Maybe.sequenceJust(Iterable)` Option#zero/ None types are result in the returned Maybe being Option.zero / None
`static <T> Option<ReactiveSeq<T>>`	`sequenceJust(java.lang.Iterable<? extends Option<T>> maybes)` Sequence operation, take a Collection of Options and turn it into a Option with a Collection Only successes are retained.
`static <T> Option<T>`	`some(T value)`
`static <T,R> Option<R>`	`tailRec(T initial, java.util.function.Function<? super T,? extends Option<? extends Either<T,R>>> fn)`
`default Maybe<T>`	`toMaybe()`
`default Trampoline<Maybe<T>>`	`toTrampoline()`
`static <T,R> Option<ReactiveSeq<R>>`	`traverse(java.util.function.Function<? super T,? extends R> fn, ReactiveSeq<Option<T>> stream)`
`default <T> Option<T>`	`unit(T unit)`
`static <T> Higher<DataWitness.option,T>`	`widen(Option<T> narrow)`
`static <C2,T> Higher<C2,Higher<DataWitness.option,T>>`	`widen2(Higher<C2,Option<T>> nestedMaybe)`
`default <T2,R> Option<R>`	`zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`default <T2,R> Option<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> Option<Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`default <S,U> Option<Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)`
`default <S,U,R> Option<R>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Function3<? super T,? super S,? super U,? extends R> fn3)`
`default <T2,T3,T4> Option<Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)`
`default <T2,T3,T4,R> Option<R>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Function4<? super T,? super T2,? super T3,? super T4,? extends R> fn)`
`default <U> Option<Tuple2<T,U>>`	`zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)`

Methods inherited from interface com.oath.cyclops.types.foldable.To
to

Methods inherited from interface com.oath.cyclops.types.OrElseValue
orElseUse

Methods inherited from interface com.oath.cyclops.types.MonadicValue
arity, attemptMap, mapAsync, mapRetry, mapRetry, mapTry, mapTry

Methods inherited from interface com.oath.cyclops.types.Value
asSupplier, collect, fold, forEach, generate, iterate, iterator, mkString, newSubscriber, nonEmptyList, nonEmptyListGet, orElse, orElseGet, print, print, printErr, printOut, stream, subscribe, toEither, toLazyEither, toLeft, toOption, toOptional, toRight, toTry, toTry, toTry, transform

Methods inherited from interface java.lang.Iterable
spliterator

Methods inherited from interface com.oath.cyclops.matching.Sealed2
fold

Methods inherited from interface com.oath.cyclops.hkt.Higher
applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.oath.cyclops.hkt.Convert
convert

Field Detail
- EMPTY
```
static final Option EMPTY
```

Method Detail

attempt

static <T> Option<T> attempt(CheckedSupplier<T> s)

attemptFlatMap

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

tailRec

static <T,R> Option<R> tailRec(T initial,
                               java.util.function.Function<? super T,? extends Option<? extends Either<T,R>>> fn)

narrowK

static <T> Option<T> narrowK(Higher<DataWitness.option,T> opt)

widen

static <T> Higher<DataWitness.option,T> widen(Option<T> narrow)

widen2

static <C2,T> Higher<C2,Higher<DataWitness.option,T>> widen2(Higher<C2,Option<T>> nestedMaybe)

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

Get the zero Maybe (single instance)

some
```
static <T> Option<T> some(T value)
```

fromFuture

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

concatMap
```
default <R> Option<R> concatMap(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).concatMap(i->Arrays.asList(()->i*3,20);
   //Maybe[9]

 
```
Specified by:

concatMap in interface MonadicValue<T>

Parameters:

mapper - transformation function

Returns:

MonadicValue

orElseUse
```
default Option<T> orElseUse(Option<T> opt)
```
Specified by:

orElseUse in interface OrElseValue<T,Option<T>>

mergeMap
```
default <R> Option<R> mergeMap(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).mergeMap(i->Flux.just(()->i*3,20);
   //Future[9]

 
```
Specified by:

mergeMap in interface MonadicValue<T>

Parameters:

mapper - transformation function

Returns:

MonadicValue

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

        Option<Integer> maybe = Option.fromPublisher(stream);

        //Option[1]

 
 
```
Parameters:

pub - Publisher to extract value from

Returns:

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

fromIterable
```
static <T> Option<T> fromIterable(java.lang.Iterable<T> iterable)
```
Construct an Option that contains a single value extracted from the supplied Iterable
```
 
   ReactiveSeq<Integer> stream =  ReactiveSeq.of(1,2,3);

         Option<Integer> maybe = Option.fromIterable(stream);

        //Option[1]

 
 
```
Parameters:

iterable - Iterable to extract value from

Returns:

Option populated with first value from Iterable (Option.zero if Publisher zero)

fromStream

static <R> Option<R> fromStream(java.util.stream.Stream<R> apply)

fromOptional

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

Construct an equivalent Option from the Supplied Optional

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

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

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

toTrampoline

default Trampoline<Maybe<T>> toTrampoline()

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

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

value - Value to wrap inside a Maybe

Returns:

Option containing the supplied value

lazy
```
default Maybe<T> lazy()
```

eager
```
default Option<T> eager()
```

ofNullable

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

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

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

Parameters:: value -
Returns:

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

Parameters:

broad - Maybe with covariant type parameter

Returns:

Narrowed Maybe

sequenceJust

static <T> Option<ReactiveSeq<T>> sequenceJust(java.lang.Iterable<? extends Option<T>> maybes)

Sequence operation, take a Collection of Options and turn it into a Option with a Collection Only successes are retained. By constrast with sequence(Iterable) Option#none/ None types are tolerated and ignored.

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

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

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

sequence

static <T> Option<ReactiveSeq<T>> sequence(java.lang.Iterable<? extends Option<T>> maybes)

Sequence operation, take a Collection of Options and turn it into a Option with a Collection By constrast with sequenceJust(Iterable) if any Option types are None / zero the return type will be an zero Option / None

 

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

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

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

sequence

static <T> Option<ReactiveSeq<T>> sequence(java.util.stream.Stream<? extends Option<T>> maybes)

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

 

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

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

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

sequence

static <T> Option<ReactiveSeq<T>> sequence(ReactiveSeq<? extends Option<T>> stream)

traverse

static <T,R> Option<ReactiveSeq<R>> traverse(java.util.function.Function<? super T,? extends R> fn,
                                             ReactiveSeq<Option<T>> stream)

accumulateJust

static <T,R> Option<R> accumulateJust(java.lang.Iterable<Option<T>> maybes,
                                      Reducer<R,T> 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.

 
  Option<Integer> just = Option.of(10);
    Option<Integer> none = Option.none();
 Option<PersistentSetX<Integer>> maybes = Option.accumulateJust(Seq.of(just, none, Option.of(1)), Reducers.toPersistentSetX());
    //Option.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> Option<R> accumulateJust(java.lang.Iterable<Option<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 ..
```
 
  Option<Integer> just = Option.of(10);
    Option<Integer> none = Option.none();

  Option<String> maybes = Option.accumulateJust(Seq.of(just, none, Option.of(1)), i -> "" + i,
    SemigroupK.stringConcat);
    //Option.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> Option<T> accumulateJust(Monoid<T> reducer,
                                    java.lang.Iterable<Option<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) cyclops.Monoids .
```
 

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

 
 
```
Parameters:

maybes - Maybes to accumulate

reducer - Monoid to combine values from each Maybe

Returns:

Maybe with reduced value

zipWithPublisher

default <U> Option<Tuple2<T,U>> zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)

Specified by:: zipWithPublisher in interface Zippable<T>

zip3

default <S,U> Option<Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
                                         java.lang.Iterable<? extends U> third)

Specified by:: zip3 in interface Zippable<T>

zip3

default <S,U,R> Option<R> zip3(java.lang.Iterable<? extends S> second,
                               java.lang.Iterable<? extends U> third,
                               Function3<? super T,? super S,? super U,? extends R> fn3)

Specified by:: zip3 in interface Zippable<T>

zip4

default <T2,T3,T4> Option<Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
                                                   java.lang.Iterable<? extends T3> third,
                                                   java.lang.Iterable<? extends T4> fourth)

Specified by:: zip4 in interface Zippable<T>

zip4

default <T2,T3,T4,R> Option<R> zip4(java.lang.Iterable<? extends T2> second,
                                    java.lang.Iterable<? extends T3> third,
                                    java.lang.Iterable<? extends T4> fourth,
                                    Function4<? super T,? super T2,? super T3,? super T4,? extends R> fn)

Specified by:: zip4 in interface Zippable<T>

forEach4

default <T2,R1,R2,R3,R> Option<R> forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                           java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                           Function3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                           Function4<? 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> Option<R> forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                           java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                           Function3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                           Function4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                           Function4<? 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> Option<R> forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                        java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                        Function3<? 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> Option<R> forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                        java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                        Function3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                        Function3<? 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> Option<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> Option<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 stream
```
 
  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>

Parameters:

value1 - Nested monadic type 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 Streams that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

zip
```
default <T2,R> Option<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 Zippable<T>

Parameters:

app - to zip with

fn - Zip function

Returns:

Combined zippable

zip
```
default <T2,R> Option<R> zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn,
                             org.reactivestreams.Publisher<? extends T2> app)
```
Description copied from interface: Zippable

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

Specified by:

zip in interface Zippable<T>

Parameters:

fn - Zip / combining function

app - to combine with

Returns:

Combined zippable

zip

default <U> Option<Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)

Specified by:: zip in interface Zippable<T>

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

unit in interface MonadicValue<T>

Specified by:

unit in interface Unit<T>

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

toMaybe in interface Value<T>

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

isPresent in interface Value<T>

recover

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

Specified by:: recover in interface Recoverable<T>

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

recoverWith

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

map
```
<R> Option<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> Option<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

fold

<R> R fold(java.util.function.Function<? super T,? extends R> some,
           java.util.function.Supplier<? extends R> none)

Specified by:: fold in interface SealedOr<T>

filter
```
Option<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> Option<U> ofType(java.lang.Class<? extends U> type)

Description copied from interface: Filters

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

 

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

Specified by:: ofType in interface Filters<T>

filterNot
```
default Option<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 Option<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

peek
```
default Option<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

emptyUnit
```
default <T1> Option<T1> emptyUnit()
```
Specified by:

emptyUnit in interface EmptyUnit<T>

Specified by:

emptyUnit in interface MonadicValue<T>

Returns:

A new, zero instance of this EmptyUnit type

fromNullable

static <T> Option<T> fromNullable(T t)

Interface Option<T>

Nested Class Summary

Field Summary

Method Summary

Methods inherited from interface com.oath.cyclops.types.foldable.To

Methods inherited from interface com.oath.cyclops.types.OrElseValue

Methods inherited from interface com.oath.cyclops.types.MonadicValue

Methods inherited from interface com.oath.cyclops.types.Value

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.oath.cyclops.matching.Sealed2

Methods inherited from interface com.oath.cyclops.hkt.Higher

Methods inherited from interface com.oath.cyclops.hkt.Convert

Field Detail

EMPTY

Method Detail

attempt

attemptFlatMap

tailRec

narrowK

widen

widen2

none

some

fromFuture

concatMap

orElseUse

mergeMap

fromPublisher

fromIterable

fromStream

fromOptional

toTrampoline

of

lazy

eager

ofNullable

narrow

sequenceJust

sequence

sequence

sequence

traverse

accumulateJust

accumulateJust

accumulateJust

zipWithPublisher

zip3

zip3

zip4

zip4

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

zip

zip

zip

unit

toMaybe

isPresent

recover

recover

recoverWith

map

flatMap

fold

filter

ofType

filterNot

notNull

peek

emptyUnit

fromNullable