cyclops.companion

Class Optionals

java.lang.Object

cyclops.companion.Optionals

public class Optionals
extends java.lang.Object

Utility class for working with JDK Optionals

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Optionals.Instances Companion class for creating Type Class instances for working with Optionals
static class	Optionals.OptionalKind<T> Simulates Higher Kinded Types for Optional's OptionalKind is a Optional and a Higher Kinded Type (optional,T)

Constructor Summary

Constructors

Constructor and Description
Optionals()

Method Summary

Modifier and Type	Method and Description
static <T,R> java.util.Optional<R>	accumulatePresent(CollectionX<java.util.Optional<T>> optionals, java.util.function.Function<? super T,R> mapper, Monoid<R> reducer) Accumulate the results only from those Optionals which have a value present, using the supplied mapping function to convert the data from each Optional 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> java.util.Optional<R>	accumulatePresent(CollectionX<java.util.Optional<T>> optionals, Reducer<R> reducer) Accummulating operation using the supplied Reducer (@see cyclops2.Reducers).
static <T> java.util.Optional<T>	accumulatePresent(Monoid<T> reducer, CollectionX<java.util.Optional<T>> optionals) Accumulate the results only from those Optionals 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 .
static <T> Active<Witness.optional,T>	allTypeclasses(java.util.Optional<T> f)
static <T1,T2,R> java.util.Optional<R>	combine(java.util.Optional<? extends T1> f, java.util.Optional<? extends T2> v, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Combine an Optional with the provided Optional using the supplied BiFunction
static <T1,T2,R> java.util.Optional<R>	combine(java.util.Optional<? extends T1> f, Value<? extends T2> v, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Combine an Optional with the provided value using the supplied BiFunction
static <W1,T> Coproduct<W1,Witness.optional,T>	coproduct(java.util.Optional<T> f, InstanceDefinitions<W1> def2)
static <T,R1,R> java.util.Optional<R>	forEach2(java.util.Optional<? extends T> value1, java.util.function.Function<? super T,? extends java.util.Optional<R1>> value2, 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 For Comprehension over a Optional, accepting a generating function.
static <T,R1,R> java.util.Optional<R>	forEach2(java.util.Optional<? extends T> value1, java.util.function.Function<? super T,java.util.Optional<R1>> value2, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a For Comprehension over a Optional, accepting a generating function.
static <T1,T2,R1,R2,R> java.util.Optional<R>	forEach3(java.util.Optional<? extends T1> value1, java.util.function.Function<? super T1,? extends java.util.Optional<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends java.util.Optional<R2>> value3, Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a Optional, accepting 2 generating function.
static <T1,T2,R1,R2,R> java.util.Optional<R>	forEach3(java.util.Optional<? extends T1> value1, java.util.function.Function<? super T1,? extends java.util.Optional<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends java.util.Optional<R2>> value3, Fn3<? super T1,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a Optional, accepting 2 generating function.
static <T1,T2,T3,R1,R2,R3,R> java.util.Optional<R>	forEach4(java.util.Optional<? extends T1> value1, java.util.function.Function<? super T1,? extends java.util.Optional<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends java.util.Optional<R2>> value3, Fn3<? super T1,? super R1,? super R2,? extends java.util.Optional<R3>> value4, Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a Optional, accepting 3 generating function.
static <T1,T2,T3,R1,R2,R3,R> java.util.Optional<R>	forEach4(java.util.Optional<? extends T1> value1, java.util.function.Function<? super T1,? extends java.util.Optional<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends java.util.Optional<R2>> value3, Fn3<? super T1,? super R1,? super R2,? extends java.util.Optional<R3>> value4, Fn4<? super T1,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a Optional, accepting 3 generating function.
static <T> Cokleisli<Witness.optional,T,java.util.Optional<T>>	kindCokleisli()
static <T> Kleisli<Witness.optional,java.util.Optional<T>,T>	kindKleisli()
static <T,W extends WitnessType<W>> OptionalT<W,T>	liftM(java.util.Optional<T> opt, W witness)
<W2,T,R> Nested<Witness.optional,W2,R>	mapM(java.util.Optional<T> f, java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs)
static <T> java.util.Optional<T>	narrow(java.util.Optional<? extends T> optional) Narrow covariant type parameter
static <W1,T> Nested<Witness.optional,W1,T>	nested(java.util.Optional<Higher<W1,T>> nested, InstanceDefinitions<W1> def2)
static java.util.Optional<java.lang.Double>	optional(java.util.OptionalDouble d)
static java.util.Optional<java.lang.Integer>	optional(java.util.OptionalInt l)
static java.util.Optional<java.lang.Long>	optional(java.util.OptionalLong l)
<W1,T> Product<Witness.optional,W1,T>	product(java.util.Optional<T> f, Active<W1,T> active)
static <T> java.util.Optional<ListX<T>>	sequence(CollectionX<java.util.Optional<T>> opts) Sequence operation, take a Collection of Optionals and turn it into a Optional with a Collection By constrast with sequencePresent(CollectionX), if any Optionals are zero the result is an zero Optional
static <T> java.util.Optional<ReactiveSeq<T>>	sequence(java.util.stream.Stream<java.util.Optional<T>> opts) Sequence operation, take a Collection of Optionals and turn it into a Optional with a Collection By constrast with Optional#sequencePresent(CollectionX) if any Optional types are zero the return type will be an zero Optional
static <T> java.util.Optional<ListX<T>>	sequencePresent(CollectionX<java.util.Optional<T>> opts) Sequence operation, take a Collection of Optionals and turn it into a Optional with a Collection Only successes are retained.
static <T,R> java.util.Optional<R>	tailRec(T initial, java.util.function.Function<? super T,? extends java.util.Optional<? extends Xor<T,R>>> fn)
static <T,R> R	visit(java.util.Optional<T> optional, java.util.function.Function<? super T,? extends R> fn, java.util.function.Supplier<R> s)
static <T> Higher<Witness.optional,T>	widen(java.util.Optional<T> narrow)
static <T1,T2,R> java.util.Optional<R>	zip(java.util.Optional<? extends T1> f, java.lang.Iterable<? extends T2> v, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Combine an Optional with the provided Iterable (selecting one element if present) using the supplied BiFunction
static <T1,T2,R> java.util.Optional<R>	zip(org.reactivestreams.Publisher<? extends T2> p, java.util.Optional<? extends T1> f, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Combine an Optional with the provided Publisher (selecting one element if present) using the supplied BiFunction

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Optionals

public Optionals()

Method Detail

tailRec

public static <T,R> java.util.Optional<R> tailRec(T initial,
                                                  java.util.function.Function<? super T,? extends java.util.Optional<? extends Xor<T,R>>> fn)

kindKleisli

public static <T> Kleisli<Witness.optional,java.util.Optional<T>,T> kindKleisli()

widen

public static <T> Higher<Witness.optional,T> widen(java.util.Optional<T> narrow)

kindCokleisli

public static <T> Cokleisli<Witness.optional,T,java.util.Optional<T>> kindCokleisli()

liftM

public static <T,W extends WitnessType<W>> OptionalT<W,T> liftM(java.util.Optional<T> opt,
                                                                W witness)

nested

public static <W1,T> Nested<Witness.optional,W1,T> nested(java.util.Optional<Higher<W1,T>> nested,
                                                          InstanceDefinitions<W1> def2)

product

public <W1,T> Product<Witness.optional,W1,T> product(java.util.Optional<T> f,
                                                     Active<W1,T> active)

coproduct

public static <W1,T> Coproduct<W1,Witness.optional,T> coproduct(java.util.Optional<T> f,
                                                                InstanceDefinitions<W1> def2)

allTypeclasses

public static <T> Active<Witness.optional,T> allTypeclasses(java.util.Optional<T> f)

mapM

public <W2,T,R> Nested<Witness.optional,W2,R> mapM(java.util.Optional<T> f,
                                                   java.util.function.Function<? super T,? extends Higher<W2,R>> fn,
                                                   InstanceDefinitions<W2> defs)

visit

public static <T,R> R visit(java.util.Optional<T> optional,
                            java.util.function.Function<? super T,? extends R> fn,
                            java.util.function.Supplier<R> s)

forEach4

public static <T1,T2,T3,R1,R2,R3,R> java.util.Optional<R> forEach4(java.util.Optional<? extends T1> value1,
                                                                   java.util.function.Function<? super T1,? extends java.util.Optional<R1>> value2,
                                                                   java.util.function.BiFunction<? super T1,? super R1,? extends java.util.Optional<R2>> value3,
                                                                   Fn3<? super T1,? super R1,? super R2,? extends java.util.Optional<R3>> value4,
                                                                   Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Perform a For Comprehension over a Optional, accepting 3 generating function. This results in a four level nested internal iteration over the provided Optionals.

 

   import static com.aol.cyclops2.reactor.Optionals.forEach4;

    forEach4(Optional.just(1),
    a-> Optional.just(a+1),
    (a,b) -> Optional.<Integer>just(a+b),
    a                  (a,b,c) -> Optional.<Integer>just(a+b+c),
    Tuple::tuple)

 
 

Parameters:

value1 - top level Optional

value2 - Nested Optional

value3 - Nested Optional

value4 - Nested Optional

yieldingFunction - Generates a result per combination

Returns:

Optional with a combined value generated by the yielding function

forEach4

public static <T1,T2,T3,R1,R2,R3,R> java.util.Optional<R> forEach4(java.util.Optional<? extends T1> value1,
                                                                   java.util.function.Function<? super T1,? extends java.util.Optional<R1>> value2,
                                                                   java.util.function.BiFunction<? super T1,? super R1,? extends java.util.Optional<R2>> value3,
                                                                   Fn3<? super T1,? super R1,? super R2,? extends java.util.Optional<R3>> value4,
                                                                   Fn4<? super T1,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                                                   Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Perform a For Comprehension over a Optional, accepting 3 generating function. This results in a four level nested internal iteration over the provided Optionals.

 

  import static com.aol.cyclops2.reactor.Optionals.forEach4;

  forEach4(Optional.just(1),
    a-> Optional.just(a+1),
    (a,b) -> Optional.<Integer>just(a+b),
    (a,b,c) -> Optional.<Integer>just(a+b+c),
    (a,b,c,d) -> a+b+c+d <100,
    Tuple::tuple);

 
 

Parameters:

value1 - top level Optional

value2 - Nested Optional

value3 - Nested Optional

value4 - Nested Optional

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

Optional with a combined value generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> java.util.Optional<R> forEach3(java.util.Optional<? extends T1> value1,
                                                             java.util.function.Function<? super T1,? extends java.util.Optional<R1>> value2,
                                                             java.util.function.BiFunction<? super T1,? super R1,? extends java.util.Optional<R2>> value3,
                                                             Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

Perform a For Comprehension over a Optional, accepting 2 generating function. This results in a three level nested internal iteration over the provided Optionals.

 

   import static com.aol.cyclops2.reactor.Optionals.forEach3;

    forEach3(Optional.just(1),
    a-> Optional.just(a+1),
    (a,b) -> Optional.<Integer>just(a+b),
    Tuple::tuple)

 
 

Parameters:

value1 - top level Optional

value2 - Nested Optional

value3 - Nested Optional

yieldingFunction - Generates a result per combination

Returns:

Optional with a combined value generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> java.util.Optional<R> forEach3(java.util.Optional<? extends T1> value1,
                                                             java.util.function.Function<? super T1,? extends java.util.Optional<R1>> value2,
                                                             java.util.function.BiFunction<? super T1,? super R1,? extends java.util.Optional<R2>> value3,
                                                             Fn3<? super T1,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                                             Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

Perform a For Comprehension over a Optional, accepting 2 generating function. This results in a three level nested internal iteration over the provided Optionals.

 

  import static com.aol.cyclops2.reactor.Optionals.forEach3;

  forEach3(Optional.just(1),
    a-> Optional.just(a+1),
    (a,b) -> Optional.<Integer>just(a+b),
    (a,b,c) -> a+b+c <100,
    Tuple::tuple);

 
 

Parameters:

value1 - top level Optional

value2 - Nested Optional

value3 - Nested Optional

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

Optional with a combined value generated by the yielding function

forEach2

public static <T,R1,R> java.util.Optional<R> forEach2(java.util.Optional<? extends T> value1,
                                                      java.util.function.Function<? super T,java.util.Optional<R1>> value2,
                                                      java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

Perform a For Comprehension over a Optional, accepting a generating function. This results in a two level nested internal iteration over the provided Optionals.

 

   import static com.aol.cyclops2.reactor.Optionals.forEach;

    forEach(Optional.just(1),
    a-> Optional.just(a+1),
    Tuple::tuple)

 
 

Parameters:

value1 - top level Optional

value2 - Nested Optional

yieldingFunction - Generates a result per combination

Returns:

Optional with a combined value generated by the yielding function

forEach2

public static <T,R1,R> java.util.Optional<R> forEach2(java.util.Optional<? extends T> value1,
                                                      java.util.function.Function<? super T,? extends java.util.Optional<R1>> value2,
                                                      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 For Comprehension over a Optional, accepting a generating function. This results in a two level nested internal iteration over the provided Optionals.

 

  import static com.aol.cyclops2.reactor.Optionals.forEach;

  forEach(Optional.just(1),
    a-> Optional.just(a+1),
    (a,b) -> Optional.<Integer>just(a+b),
    (a,b,c) -> a+b+c <100,
    Tuple::tuple);

 
 

Parameters:

value1 - top level Optional

value2 - Nested Optional

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

Optional with a combined value generated by the yielding function

optional

public static java.util.Optional<java.lang.Double> optional(java.util.OptionalDouble d)

optional

public static java.util.Optional<java.lang.Long> optional(java.util.OptionalLong l)

optional

public static java.util.Optional<java.lang.Integer> optional(java.util.OptionalInt l)

sequence

public static <T> java.util.Optional<ListX<T>> sequence(CollectionX<java.util.Optional<T>> opts)

Sequence operation, take a Collection of Optionals and turn it into a Optional with a Collection By constrast with sequencePresent(CollectionX), if any Optionals are zero the result is an zero Optional

 
 
  Optional<Integer> just = Optional.of(10);
        Optional<Integer> none = Optional.zero();
  
  Optional<ListX<Integer>> opts = Optionals.sequence(ListX.of(just, none, Optional.of(1)));
        //Optional.zero();
 
 
 

Parameters:

maybes - Maybes to Sequence

Returns:

Maybe with a List of values

sequencePresent

public static <T> java.util.Optional<ListX<T>> sequencePresent(CollectionX<java.util.Optional<T>> opts)

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

  
  Optional<Integer> just = Optional.of(10);
        Optional<Integer> none = Optional.zero();
 
 Optional<ListX<Integer>> maybes = Optionals.sequencePresent(ListX.of(just, none, Optional.of(1)));
       //Optional.of(ListX.of(10, 1));
 
 

Parameters:

opts - Optionals to Sequence

Returns:

Optional with a List of values

sequence

public static <T> java.util.Optional<ReactiveSeq<T>> sequence(java.util.stream.Stream<java.util.Optional<T>> opts)

Sequence operation, take a Collection of Optionals and turn it into a Optional with a Collection By constrast with Optional#sequencePresent(CollectionX) if any Optional types are zero the return type will be an zero Optional

 
 
  Optional<Integer> just = Optional.of(10);
        Optional<Integer> none = Optional.zero();
  
  Optional<ListX<Integer>> maybes = Optionals.sequence(ListX.of(just, none, Optional.of(1)));
        //Optional.zero();
 
 
 

Parameters:

opts - Maybes to Sequence

Returns:

Optional with a List of values

accumulatePresent

public static <T,R> java.util.Optional<R> accumulatePresent(CollectionX<java.util.Optional<T>> optionals,
                                                            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 Optionals.

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

Parameters:

optionals - Optionals to accumulate

reducer - Reducer to accumulate values with

Returns:

Optional with reduced value

accumulatePresent

public static <T,R> java.util.Optional<R> accumulatePresent(CollectionX<java.util.Optional<T>> optionals,
                                                            java.util.function.Function<? super T,R> mapper,
                                                            Monoid<R> reducer)

Accumulate the results only from those Optionals which have a value present, using the supplied mapping function to convert the data from each Optional 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 .

  
  Optional<Integer> just = Optional.of(10);
        Optional<Integer> none = Optional.zero();
        
  Optional<String> opts = Optional.accumulateJust(ListX.of(just, none, Optional.of(1)), i -> "" + i,
                                                     Monoids.stringConcat);
        //Optional.of("101")
 
 
 

Parameters:

optionals - Optionals to accumulate

mapper - Mapping function to be applied to the result of each Optional

reducer - Monoid to combine values from each Optional

Returns:

Optional with reduced value

accumulatePresent

public static <T> java.util.Optional<T> accumulatePresent(Monoid<T> reducer,
                                                          CollectionX<java.util.Optional<T>> optionals)

Accumulate the results only from those Optionals 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 .

  
  Optional<Integer> just = Optional.of(10);
        Optional<Integer> none = Optional.zero();
        
  Optional<String> opts = Optional.accumulateJust(Monoids.stringConcat,ListX.of(just, none, Optional.of(1)), 
                                                     );
        //Optional.of("101")
 
 
 

Parameters:

optionals - Optionals to accumulate

mapper - Mapping function to be applied to the result of each Optional

reducer - Monoid to combine values from each Optional

Returns:

Optional with reduced value

combine

public static <T1,T2,R> java.util.Optional<R> combine(java.util.Optional<? extends T1> f,
                                                      Value<? extends T2> v,
                                                      java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Combine an Optional with the provided value using the supplied BiFunction

  
  Optionals.combine(Optional.of(10),Maybe.just(20), this::add)
  //Optional[30]
  
  private int add(int a, int b) {
            return a + b;
        }
  
 
 

Parameters:

f - Optional to combine with a value

v - Value to combine

fn - Combining function

Returns:

Optional combined with supplied value

combine

public static <T1,T2,R> java.util.Optional<R> combine(java.util.Optional<? extends T1> f,
                                                      java.util.Optional<? extends T2> v,
                                                      java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Combine an Optional with the provided Optional using the supplied BiFunction

  
  Optionals.combine(Optional.of(10),Optional.of(20), this::add)
  //Optional[30]
  
  private int add(int a, int b) {
            return a + b;
        }
  
 
 

Parameters:

f - Optional to combine with a value

v - Optional to combine

fn - Combining function

Returns:

Optional combined with supplied value, or zero Optional if no value present

zip

public static <T1,T2,R> java.util.Optional<R> zip(java.util.Optional<? extends T1> f,
                                                  java.lang.Iterable<? extends T2> v,
                                                  java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Combine an Optional with the provided Iterable (selecting one element if present) using the supplied BiFunction

  
  Optionals.zip(Optional.of(10),Arrays.asList(20), this::add)
  //Optional[30]
  
  private int add(int a, int b) {
            return a + b;
        }
  
 
 

Parameters:

f - Optional to combine with first element in Iterable (if present)

v - Iterable to combine

fn - Combining function

Returns:

Optional combined with supplied Iterable, or zero Optional if no value present

zip

public static <T1,T2,R> java.util.Optional<R> zip(org.reactivestreams.Publisher<? extends T2> p,
                                                  java.util.Optional<? extends T1> f,
                                                  java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Combine an Optional with the provided Publisher (selecting one element if present) using the supplied BiFunction

  
  Optionals.zip(Flux.just(10),Optional.of(10), this::add)
  //Optional[30]
  
  private int add(int a, int b) {
            return a + b;
        }
  
 
 

Parameters:

p - Publisher to combine

f - Optional to combine with

fn - Combining function

Returns:

Optional combined with supplied Publisher, or zero Optional if no value present

narrow

public static <T> java.util.Optional<T> narrow(java.util.Optional<? extends T> optional)

Narrow covariant type parameter

Parameters:

broad - Optional with covariant type parameter

Returns:

Narrowed Optional