Optionals (cyclops-react 1.0.2 API)

java.lang.Object
- com.aol.cyclops.util.Optionals

public class Optionals
extends java.lang.Object

Utility class for working with JDK Optionals

Constructor Summary

Constructors
Constructor and Description

Optionals()

Constructors
Constructor and Description
`Optionals()`

Method Summary

All Methods Static Methods Concrete Methods
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) `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 com.aol.cyclops.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) `Monoids`.
`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 <T> java.util.Optional<T>`	`narrow(java.util.Optional<? extends T> optional)` Narrow covariant type parameter
`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 empty the result is an empty 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 empty the return type will be an empty 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 <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

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 empty the result is an empty Optional

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

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#empty types are tolerated and ignored.

  
  Optional<Integer> just = Optional.of(10);
        Optional<Integer> none = Optional.empty();
 
 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 empty the return type will be an empty Optional

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

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 com.aol.cyclops.Reducers). A typical use case is to accumulate into a Persistent Collection type. Accumulates the present results, ignores empty Optionals.

  
  Optional<Integer> just = Optional.of(10);
        Optional<Integer> none = Optional.empty();
        
 Optional<PSetX<Integer>> opts = Optional.accumulateJust(ListX.of(just, none, Optional.of(1)), Reducers.toPSetX());
       //Optional.of(PSetX.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) Monoids.

  
  Optional<Integer> just = Optional.of(10);
        Optional<Integer> none = Optional.empty();
        
  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) Monoids.

  
  Optional<Integer> just = Optional.of(10);
        Optional<Integer> none = Optional.empty();
        
  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 empty 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 empty 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 empty 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

Class Optionals

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Optionals

Method Detail

sequence

sequencePresent

sequence

accumulatePresent

accumulatePresent

accumulatePresent

combine

combine

zip

zip

narrow