Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
*
* @param value1 top level Option
* @param value2 Nested Option
* @param value3 Nested Option
* @param yieldingFunction Generates a result per combination
* @return Option with a combined value generated by the yielding function
*/
public static Option forEach3(Option value1,
Function> value2,
BiFunction> value3,
Fn3 yieldingFunction) {
return value1.flatMap(in -> {
Option a = value2.apply(in);
return a.flatMap(ina -> {
Option b = value3.apply(in,ina);
return b.map(in2 -> yieldingFunction.apply(in, ina, in2));
});
});
}
/**
*
* Perform a For Comprehension over a Option, accepting 2 generating function.
* This results in a three level nested internal iteration over the provided Options.
*
*
*
* @param value1 top level Option
* @param value2 Nested Option
* @param value3 Nested Option
* @param filterFunction A filtering function, keeps values where the predicate holds
* @param yieldingFunction Generates a result per combination
* @return Option with a combined value generated by the yielding function
*/
public static Option forEach3(Option value1,
Function> value2,
BiFunction> value3,
Fn3 filterFunction,
Fn3 yieldingFunction) {
return value1.flatMap(in -> {
Option a = value2.apply(in);
return a.flatMap(ina -> {
Option b = value3.apply(in,ina);
return b.filter(in2->filterFunction.apply(in,ina,in2))
.map(in2 -> yieldingFunction.apply(in, ina, in2));
});
});
}
/**
* Perform a For Comprehension over a Option, accepting a generating function.
* This results in a two level nested internal iteration over the provided Options.
*
*
*
* @param value1 top level Option
* @param value2 Nested Option
* @param yieldingFunction Generates a result per combination
* @return Option with a combined value generated by the yielding function
*/
public static Option forEach2(Option value1, Function> value2,
BiFunction yieldingFunction) {
return value1.flatMap(in -> {
Option a = value2.apply(in);
return a.map(in2 -> yieldingFunction.apply(in, in2));
});
}
/**
*
* Perform a For Comprehension over a Option, accepting a generating function.
* This results in a two level nested internal iteration over the provided Options.
*
*
*
* @param value1 top level Option
* @param value2 Nested Option
* @param filterFunction A filtering function, keeps values where the predicate holds
* @param yieldingFunction Generates a result per combination
* @return Option with a combined value generated by the yielding function
*/
public static Option forEach2(Option value1, Function> value2,
BiFunction filterFunction,
BiFunction yieldingFunction) {
return value1.flatMap(in -> {
Option a = value2.apply(in);
return a.filter(in2->filterFunction.apply(in,in2))
.map(in2 -> yieldingFunction.apply(in, in2));
});
}
public static Option optional(OptionalDouble d){
return d.isPresent() ? Option.of(d.getAsDouble()) : Option.none();
}
public static Option optional(OptionalLong l){
return l.isPresent() ? Option.of(l.getAsLong()) : Option.none();
}
public static Option optional(OptionalInt l){
return l.isPresent() ? Option.of(l.getAsInt()) : Option.none();
}
/**
* Sequence operation, take a Collection of Options and turn it into a Option with a Collection
* By constrast with {@link Options#sequencePresent(CollectionX)}, if any Options are empty the result
* is an empty Option
*
*
*
*
* @param opts Maybes to Sequence
* @return Maybe with a List of values
*/
public static Option> sequence(final CollectionX> opts) {
return sequence(opts.stream()).map(s -> s.toListX());
}
/**
* Sequence operation, take a Collection of Options and turn it into a Option with a Collection
* Only successes are retained. By constrast with {@link Options#sequence(CollectionX)} Option#empty types are
* tolerated and ignored.
*
*
*
* @param opts Options to Sequence
* @return Option with a List of values
*/
public static Option> sequencePresent(final CollectionX> opts) {
return sequence(opts.stream().filter(Option::isDefined)).map(s->s.toListX());
}
/**
* Sequence operation, take a Collection of Options and turn it into a Option with a Collection
* By constrast with {@link Options#sequencePresent(CollectionX)} if any Option types are empty
* the return type will be an empty Option
*
*
*
*
* @param opts Maybes to Sequence
* @return Option with a List of values
*/
public static Option> sequence(final java.util.stream.Stream> opts) {
return AnyM.sequence(opts.map(Options::anyM), option.INSTANCE)
.map(ReactiveSeq::fromStream)
.to(VavrWitness::option);
}
/**
* 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 empty Options.
*
*
*
* @param optionals Options to accumulate
* @param reducer Reducer to accumulate values with
* @return Option with reduced value
*/
public static Option accumulatePresent(final CollectionX> optionals, final Reducer reducer) {
return sequencePresent(optionals).map(s -> s.mapReduce(reducer));
}
/**
* Accumulate the results only from those Options which have a value present, using the supplied mapping function to
* convert the data from each Option 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) {@see cyclops2.Monoids }.
*
*
* {@code
* Option just = Option.of(10);
Option none = Option.empty();
* Option opts = Option.accumulateJust(ListX.of(just, none, Option.of(1)), i -> "" + i,
Monoids.stringConcat);
//Option.of("101")
*
* }
*
*
* @param optionals Options to accumulate
* @param mapper Mapping function to be applied to the result of each Option
* @param reducer Monoid to combine values from each Option
* @return Option with reduced value
*/
public static Option accumulatePresent(final CollectionX> optionals, final Function mapper,
final Monoid reducer) {
return sequencePresent(optionals).map(s -> s.map(mapper)
.reduce(reducer));
}
/**
* Accumulate the results only from those Options 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) {@see cyclops2.Monoids }.
*
*
*
* @param optionals Options to accumulate
* @param reducer Monoid to combine values from each Option
* @return Option with reduced value
*/
public static Option accumulatePresent(final Monoid reducer, final CollectionX> optionals) {
return sequencePresent(optionals).map(s -> s
.reduce(reducer));
}
/**
* Combine an Option with the provided value using the supplied BiFunction
*
*
* {@code
* Options.combine(Option.of(10),Maybe.just(20), this::add)
* //Option[30]
*
* private int add(int a, int b) {
return a + b;
}
*
* }
*
* @param f Option to combine with a value
* @param v Value to combine
* @param fn Combining function
* @return Option combined with supplied value
*/
public static Option combine(final Option f, final Value v,
final BiFunction fn) {
return narrow(FromCyclopsReact.option(ToCyclopsReact.maybe(f)
.combine(v, fn)));
}
/**
* Combine an Option with the provided Option using the supplied BiFunction
*
*
* {@code
* Options.combine(Option.of(10),Option.of(20), this::add)
* //Option[30]
*
* private int add(int a, int b) {
return a + b;
}
*
* }
*
*
* @param f Option to combine with a value
* @param v Option to combine
* @param fn Combining function
* @return Option combined with supplied value, or empty Option if no value present
*/
public static Option combine(final Option f, final Option v,
final BiFunction fn) {
return combine(f,ToCyclopsReact.maybe(v),fn);
}
/**
* Combine an Option with the provided Iterable (selecting one element if present) using the supplied BiFunction
*
* {@code
* Options.zip(Option.of(10),Arrays.asList(20), this::add)
* //Option[30]
*
* private int add(int a, int b) {
return a + b;
}
*
* }
*
* @param f Option to combine with first element in Iterable (if present)
* @param v Iterable to combine
* @param fn Combining function
* @return Option combined with supplied Iterable, or empty Option if no value present
*/
public static Option zip(final Option f, final Iterable v,
final BiFunction fn) {
return narrow(FromCyclopsReact.option(ToCyclopsReact.maybe(f)
.zip(v, fn)));
}
/**
* Combine an Option with the provided Publisher (selecting one element if present) using the supplied BiFunction
*
* {@code
* Options.zip(Flux.just(10),Option.of(10), this::add)
* //Option[30]
*
* private int add(int a, int b) {
return a + b;
}
*
* }
*
*
* @param p Publisher to combine
* @param f Option to combine with
* @param fn Combining function
* @return Option combined with supplied Publisher, or empty Option if no value present
*/
public static Option zip(final Publisher p, final Option f,
final BiFunction fn) {
return narrow(FromCyclopsReact.option(ToCyclopsReact.maybe(f)
.zipP(p, fn)));
}
/**
* Narrow covariant type parameter
*
* @param optional Option with covariant type parameter
* @return Narrowed Option
*/
public static Option narrow(final Option optional) {
return (Option) optional;
}
public static Active allTypeclasses(Option option){
return Active.of(widen(option), Options.Instances.definitions());
}
public static Nested mapM(Option option, Function> fn, InstanceDefinitions defs){
Option> e = option.map(fn);
OptionKind> lk = widen(e);
return Nested.of(lk, Options.Instances.definitions(), defs);
}
/**
* Companion class for creating Type Class instances for working with Options
* @author johnmcclean
*
*/
@UtilityClass
public static class Instances {
public static InstanceDefinitions
