net.adamcin.oakpal.api

Class Fun

java.lang.Object

net.adamcin.oakpal.api.Fun

public final class Fun
extends Object

This alphabet soup provides function transformation methods targeting usage within Java 8+ Streams. Major support for the following functional primitives:

1. Function
2. BiFunction
3. Consumer
4. BiConsumer
5. Predicate
6. BiPredicate
7. Supplier

In addition, the Map.Entry type is treated as a 2-n tuple, or pair, for mapping Map.entrySet() streams to bifunctions, bipredicates, and biconsumers. Some methods here serve a very simple purpose of supporting immediate type inference of method references, like infer1(Function), which allows infer1(String::valueOf).andThen(). To support method overloads in lambda and method ref type inference is in play, many method names have a numeric suffix of 0, 1, or 2. (Sometimes the 1 is omitted even when "0" and "2" overloads are defined). This suffix indicates the highest *arity of function arguments, and often represents the arity of a returned function type as well. A Supplier argument represents an *arity of 0, because it takes 0 arguments in order to return a value. A Function has an *arity of 1, because it accepts one argument to return one value. A BiFunction accepts two arguments, and therefore has an *arity of 2. Consumers and Predicates also have an *arity of 1, and BiConsumers and BiPredicates also have an *arity of 2. Another area of treatment is transformation of checked signatures to unchecked signatures via the following functional interfaces:

1. Fun.ThrowingFunction
2. Fun.ThrowingBiFunction
3. Fun.ThrowingConsumer
4. Fun.ThrowingBiConsumer
5. Fun.ThrowingPredicate
6. Fun.ThrowingBiPredicate
7. Fun.ThrowingSupplier

The uncheck* methods will catch any checked exception thrown by the above types and rethrow as a Fun.FunRuntimeException. The result* methods will catch any exception (checked or not) and transform the return type signature to wrap with Result. For Fun.ThrowingConsumer and Fun.ThrowingBiConsumer, there is no return type to wrap, so resultNothing1(ThrowingConsumer) and resultNothing2(ThrowingBiConsumer) will transform the consumers to equivalent functions that return a Result wrapping the Nothing sentinel type.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Fun.FunRuntimeException Wrapping runtime error type for unchecked throwing functions.
static interface	Fun.ThrowingBiConsumer<K,V> Inferrable type for BiConsumers that throw.
static interface	Fun.ThrowingBiFunction<K,V,R> Inferrable type for BiFunctions that throw.
static interface	Fun.ThrowingBiPredicate<K,V> Inferrable type for BiPredicates that throw.
static interface	Fun.ThrowingConsumer<T> Inferrable type for Consumers that throw.
static interface	Fun.ThrowingFunction<T,R> Inferrable type for Functions that throw.
static interface	Fun.ThrowingPredicate<T> Inferrable type for Predicates that throw
static interface	Fun.ThrowingSupplier<R> Inferrable type for Suppliers that throw.

Method Summary

Modifier and Type	Method and Description
static <R,S> Supplier<S>	compose0(@NotNull Supplier<? extends R> before, @NotNull Function<? super R,? extends S> after) Compose a Supplier with a Function that maps the original supplied type to a new supplied type.
static <T,I,R> Function<T,R>	compose1(@NotNull Function<T,? extends I> before, @NotNull Function<? super I,? extends R> after) Essentially the same as calling Function.andThen(Function), except needing no cast for a method reference as the before argument, resulting in function composition of before followed by after.
static <K,V,I,R> BiFunction<K,V,R>	compose2(@NotNull BiFunction<K,V,? extends I> before, @NotNull Function<? super I,? extends R> after) Essentially the same as calling BiFunction.andThen(Function), except needing no cast for a method reference as the before argument, resulting in function composition of before followed by after.
static <T,P> Predicate<T>	composeTest1(@NotNull Function<? super T,? extends P> inputFunction, @NotNull Predicate<? super P> testResult) Compose a Predicate with a preceding input Function that maps the stream element type to the input type of the Predicate.
static <K,V,P> BiPredicate<K,V>	composeTest2(@NotNull BiFunction<? super K,? super V,? extends P> inputFunction, @NotNull Predicate<? super P> testResult) Compose a BiPredicate with a single preceding BiFunction that maps the stream Entry element key and value types to the input type of the provided Predicate.
static <K,V,P,Q> BiPredicate<K,V>	composeTest2(@NotNull Function<? super K,? extends P> inputTFunction, @NotNull Function<? super V,? extends Q> inputUFunction, @NotNull BiPredicate<? super P,? super Q> testResult) Compose a BiPredicate with preceding left and right input Functions that map the stream Entry element key and value types to the respective input type of the provided BiPredicate.
static <M,R> Supplier<M>	composeTry0(@NotNull Function<? super R,? extends M> monoidSuccess, @NotNull Function<? super Exception,? extends M> monoidError, @NotNull Fun.ThrowingSupplier<? extends R> mayThrowOnGet) Composes four lambdas into a single supplier for use with flatMap() defined by Stream, Optional, etc.
static <M,R> Supplier<M>	composeTry0(@NotNull Function<? super R,? extends M> monadUnit, @NotNull Supplier<? extends M> monadZero, @NotNull Fun.ThrowingSupplier<? extends R> mayThrowOnGet, @Nullable Consumer<? super Exception> onError) Composes four lambdas into a single supplier for use with flatMap() defined by Stream, Optional, etc.
static <M,T,R> Function<T,M>	composeTry1(@NotNull Function<? super R,? extends M> monoidSuccess, @NotNull Function<? super Exception,? extends M> monoidError, @NotNull Fun.ThrowingFunction<? super T,? extends R> mayThrowOnApply) Composes four lambdas into a single function for use with flatMap() defined by Stream, Optional, etc.
static <M,T,R> Function<T,M>	composeTry1(@NotNull Function<? super R,? extends M> monadUnit, @NotNull Supplier<? extends M> monadZero, @NotNull Fun.ThrowingFunction<? super T,? extends R> mayThrowOnApply, @Nullable BiConsumer<? super T,? super Exception> onError) Composes four lambdas into a single function for use with flatMap() defined by Stream, Optional, etc.
static <M,K,V,R> BiFunction<K,V,M>	composeTry2(@NotNull Function<? super R,? extends M> monoidSuccess, @NotNull Function<? super Exception,? extends M> monoidError, @NotNull Fun.ThrowingBiFunction<? super K,? super V,? extends R> mayThrowOnApply) Composes four lambdas into a single function for use with flatMap() defined by Stream, Optional, etc.
static <M,K,V,R> BiFunction<K,V,M>	composeTry2(@NotNull Function<? super R,? extends M> monadUnit, @NotNull Supplier<? extends M> monadZero, @NotNull Fun.ThrowingBiFunction<? super K,? super V,? extends R> mayThrowOnApply, @Nullable BiConsumer<? super Map.Entry<? super K,? super V>,? super Exception> onError) Composes four lambdas into a single bifunction for use with flatMap() defined by Stream, Optional, etc.
static <T,R> @NotNull Function<T,R>	constantly1(@NotNull Supplier<? extends R> supplier) Fits a supplier into a pipeline as a constant Function.
static <K,V,R> @NotNull BiFunction<K,V,R>	constantly2(@NotNull Supplier<? extends R> supplier) Fits a supplier into a pipeline as a constant BiFunction.
static <K,V> Collector<Map.Entry<K,V>,?,Map<K,V>>	entriesToMap() Shorthand for Collectors.toMap(Function, Function) for collecting streams of Map.Entry, except using keepLastMerger() as the merge function, and LinkedHashMap as the supplied map type.
static <K,V> Collector<Map.Entry<K,V>,?,Map<K,V>>	entriesToMap(@NotNull BinaryOperator<V> mergeFunction) Shorthand for Collectors.toMap(Function, Function, BinaryOperator, Supplier) for collecting streams of Map.Entry, except using LinkedHashMap as the supplied map type.
static <K,V> Collector<Map.Entry<K,V>,?,Map<K,V>>	entriesToMapOfType(@NotNull Supplier<Map<K,V>> mapSupplier) Shorthand for Collectors.toMap(Function, Function, BinaryOperator, Supplier) for collecting streams of Map.Entry, except using keepLastMerger() as the merge function.
static <K,V> Collector<Map.Entry<K,V>,?,Map<K,V>>	entriesToMapOfType(@NotNull Supplier<Map<K,V>> mapSupplier, @NotNull BinaryOperator<V> mergeFunction) Shorthand for Collectors.toMap(Function, Function, BinaryOperator, Supplier) for collecting streams of Map.Entry.
static <K,V> Function<Map.Entry<K,V>,Map.Entry<K,V>>	entryTee(@NotNull BiConsumer<? super K,? super V> consumer) Like tee(Consumer), this method transforms a BiConsumer into a "tee" (like the Unix command, evoking the shape of the letter, 'T') function for Map.Entry streams, that passes the input entry to output after calling BiConsumer.accept(Object, Object) with the input entry key and value.
static <T> Supplier<T>	infer0(@NotNull Supplier<? extends T> methodRef) Infers a method ref to a Supplier.
static <T,R> Function<T,R>	infer1(@NotNull Function<? super T,? extends R> methodRef) Infers a static method ref to a Function.
static <K,V,R> BiFunction<K,V,R>	infer2(@NotNull BiFunction<? super K,? super V,? extends R> methodRef) Infers a static method ref to a BiFunction.
static <T> Predicate<T>	inferTest1(@NotNull Predicate<? super T> methodRef) Infers a method ref to a Predicate.
static <K,V> BiPredicate<K,V>	inferTest2(@NotNull BiPredicate<? super K,? super V> methodRef) Infers a method ref to a BiPredicate.
static <T,S extends Collection<? super T>> Predicate<T>	inSet(S haystack) This method is used to support type inference around the Collection.contains(Object) method, whose argument is not otherwise typed with the element type parameter of the collection.
static <K,M extends Map<? super K,?>> Predicate<K>	isKeyIn(M haystack) This method is used to support type inference around the Map.containsKey(Object) method, whose argument is not otherwise typed with the key type parameter of the Map.
static <V,M extends Map<?,? super V>> Predicate<V>	isValueIn(M haystack) This method is used to support type inference around the Map.containsValue(Object) method, whose argument is not otherwise typed with the value type parameter of the Map.
static <V> BinaryOperator<V>	keepFirstMerger() A merge function for entriesToMap(BinaryOperator) and entriesToMapOfType(Supplier, BinaryOperator) that keeps the first element defined for a key when merging duplicates.
static <V> BinaryOperator<V>	keepLastMerger() A merge function for entriesToMap(BinaryOperator) and entriesToMapOfType(Supplier, BinaryOperator) that keeps the last element defined for a key when merging duplicates.
static <K,V,R> Function<Map.Entry<K,V>,R>	mapEntry(@NotNull BiFunction<? super K,? super V,? extends R> biMapFunction) Transform a BiFunction to a Function over Map.Entry stream elements of the same key and value type parameters.
static <K,V,L> Function<Map.Entry<K,V>,Map.Entry<L,V>>	mapKey(@NotNull BiFunction<? super K,? super V,? extends L> keyBiFunction) Transform a BiFunction to a Function over Map.Entry stream elements of the same key and value type parameters, that returns new Map.Entry elements that retain the input value but take the output of the BiFunction as the new key.
static <K,V,L> Function<Map.Entry<K,V>,Map.Entry<L,V>>	mapKey(@NotNull Function<? super K,? extends L> keyFunction) Transform a Function over key types to a Function over Map.Entry stream elements whose key type matches the input type of the Function, that returns new Map.Entry elements that retain the input value but take the output of the Function as the new key.
static <K,V,W> Function<Map.Entry<K,V>,Map.Entry<K,W>>	mapValue(@NotNull BiFunction<? super K,? super V,? extends W> valueBiFunction) Transform a BiFunction to a Function over Map.Entry stream elements of the same key and value type parameters, that returns new Map.Entry elements that retain the input key but take the output of the BiFunction as the new value.
static <K,V,W> Function<Map.Entry<K,V>,Map.Entry<K,W>>	mapValue(@NotNull Function<? super V,? extends W> valueFunction) Transform a Function over value types to a Function over Map.Entry stream elements whose value type matches the input type of the Function, that returns new Map.Entry elements that retain the input key but take the output of the Function as the new value.
static <K,V> Consumer<Map.Entry<K,V>>	onEntry(@NotNull BiConsumer<? super K,? super V> biConsumer) Transform a BiConsumer to a Consumer of Map.Entry stream elements with matching respective key and value type parameters.
static <K,V> Consumer<Map.Entry<K,V>>	onKey(@NotNull Consumer<? super K> consumer) Transform a Consumer of key types to a Consumer of Map.Entry stream elements with a matching key type parameter.
static <K,V> Consumer<Map.Entry<K,V>>	onValue(@NotNull Consumer<? super V> consumer) Transform a Consumer of value types to a Consumer of Map.Entry stream elements with a matching value type parameter.
static <R> Supplier<Result<R>>	result0(@NotNull Fun.ThrowingSupplier<? extends R> mayThrowOnGet) Transform a Fun.ThrowingSupplier to a Supplier of Result whose success type parameter is the same as the type parameter of the Fun.ThrowingSupplier.
static <T,R> Function<T,Result<R>>	result1(@NotNull Fun.ThrowingFunction<? super T,? extends R> mayThrowOnApply) Transform a Fun.ThrowingFunction to a Function over the same input type parameter, which returns a Result whose success type parameter is the same as the output type of the Fun.ThrowingFunction.
static <K,V,R> BiFunction<K,V,Result<R>>	result2(@NotNull Fun.ThrowingBiFunction<? super K,? super V,? extends R> mayThrowOnApply) Transform a Fun.ThrowingBiFunction to a BiFunction over the same input type parameters, which returns a Result whose success type parameter is the same as the output type of the Fun.ThrowingBiFunction.
static <T> Function<T,Result<Nothing>>	resultNothing1(@NotNull Fun.ThrowingConsumer<? super T> mayThrowOnAccept) Transform a Fun.ThrowingConsumer to a Function over the same input type parameter, but which returns a Result of success type Nothing.
static <K,V> BiFunction<K,V,Result<Nothing>>	resultNothing2(@NotNull Fun.ThrowingBiConsumer<? super K,? super V> mayThrowOnAccept) Transform a Fun.ThrowingBiConsumer to a BiFunction over the same input type parameters, but which returns a Result of success type Nothing.
static <T> Stream<T>	streamIt(T element) What's the most efficient way to stream a single nullable element? I don't know, but maybe I randomly got it right under the hood.
static <T> Stream<T>	streamOpt(@NotNull Optional<T> element) Use this to transform a less useful Optional into an equivalent single-element stream.
static <T> @NotNull Function<T,T>	tee(@NotNull Consumer<? super T> consumer) Transform a consumer into a "tee" (like the Unix command, evoking the shape of the letter, 'T') function that passes the input argument to output after calling Consumer.accept(Object) with the input.
static <K,V> Predicate<? super Map.Entry<K,V>>	testEntry(@NotNull BiPredicate<? super K,? super V> biPredicate) Transform a BiPredicate to a Predicate testing Map.Entry stream elements with matching respective key and value type parameters.
static <K,V> Predicate<? super Map.Entry<K,V>>	testKey(@NotNull Predicate<? super K> keyPredicate) Transform a Predicate of key types to a Predicate testing Map.Entry stream elements with a matching key type parameter.
static <T> Predicate<T>	testOrDefault1(@NotNull Fun.ThrowingPredicate<? super T> mayThrowOnTest, boolean defaultValue) Transform a Fun.ThrowingPredicate to a Predicate, providing a default boolean value to return if an exception is thrown.
static <K,V> BiPredicate<K,V>	testOrDefault2(@NotNull Fun.ThrowingBiPredicate<? super K,? super V> mayThrowOnTest, boolean defaultValue) Transform a Fun.ThrowingBiPredicate to a BiPredicate, providing a default boolean value to return if an exception is thrown.
static <K,V> Predicate<? super Map.Entry<K,V>>	testValue(@NotNull Predicate<? super V> valuePredicate) Transform a Predicate of value types to a Predicate testing Map.Entry stream elements with a matching value type parameter.
static <V> BinaryOperator<V>	throwingMerger() A merge function for entriesToMap(BinaryOperator) and entriesToMapOfType(Supplier, BinaryOperator) that throws an IllegalStateException when merging duplicates to guarantee distinct pairs.
static <T> Fun.ThrowingFunction<T,Nothing>	throwingVoidToNothing1(@NotNull Fun.ThrowingConsumer<? super T> mayThrowOnAccept) Parallel method to Nothing.voidToNothing1(Consumer), for transforming a Fun.ThrowingConsumer to a Fun.ThrowingFunction that returns Nothing.
static <K,V> Fun.ThrowingBiFunction<K,V,Nothing>	throwingVoidToNothing2(@NotNull Fun.ThrowingBiConsumer<? super K,? super V> mayThrowOnAccept) Parallel method to Nothing.voidToNothing2(BiConsumer), for transforming a Fun.ThrowingBiConsumer to a Fun.ThrowingBiFunction that returns Nothing.
static <K,V> Map.Entry<K,V>	toEntry(K key, V value) An alias for creating a AbstractMap.SimpleImmutableEntry for the provided key and value.
static <T> Consumer<T>	toVoid1(@NotNull Function<? super T,?> inputFunction) Infers a Function.apply(Object) signature as a Consumer.
static <K,V> BiConsumer<K,V>	toVoid2(@NotNull BiFunction<? super K,? super V,?> inputFunction) Infers a BiFunction.apply(Object, Object) signature as a BiConsumer.
static <R> Supplier<R>	tryOrDefault0(@NotNull Fun.ThrowingSupplier<R> mayThrowOnGet, R defaultValue) Transform a Fun.ThrowingSupplier to a Supplier, providing a default value to return if an exception is thrown.
static <T,R> Function<T,R>	tryOrDefault1(@NotNull Fun.ThrowingFunction<? super T,R> mayThrowOnApply, R defaultValue) Transform a Fun.ThrowingFunction to a Function, providing a default value to return if an exception is thrown.
static <K,V,R> BiFunction<K,V,R>	tryOrDefault2(@NotNull Fun.ThrowingBiFunction<? super K,? super V,R> mayThrowOnApply, R defaultValue) Transform a Fun.ThrowingBiFunction to a BiFunction, providing a default value to return if an exception is thrown.
static <R> Supplier<Optional<R>>	tryOrOptional0(@NotNull Fun.ThrowingSupplier<R> mayThrowOnGet) Transform a Fun.ThrowingSupplier to a Supplier of the same type, wrapped in an Optional.
static <T,R> Function<T,Optional<R>>	tryOrOptional1(@NotNull Fun.ThrowingFunction<? super T,R> mayThrowOnApply) Transform a Fun.ThrowingFunction to a Function of the same input type, with the output type wrapped in an Optional.
static <K,V,R> BiFunction<K,V,Optional<R>>	tryOrOptional2(@NotNull Fun.ThrowingBiFunction<? super K,? super V,R> mayThrowOnApply) Transform a Fun.ThrowingBiFunction to a BiFunction of the same input types, with the output type wrapped in an Optional.
static <T> Consumer<T>	tryOrVoid1(@NotNull Fun.ThrowingConsumer<? super T> mayThrowOnAccept) Transform a Fun.ThrowingConsumer to a Consumer of the same input type, that simply suppresses any exceptions if thrown.
static <K,V> BiConsumer<K,V>	tryOrVoid2(@NotNull Fun.ThrowingBiConsumer<? super K,? super V> mayThrowOnAccept) Transform a Fun.ThrowingBiConsumer to a BiConsumer of the same input types, that simply suppresses any exceptions if thrown.
static <R> Supplier<R>	uncheck0(@NotNull Fun.ThrowingSupplier<? extends R> mayThrowOnGet) Transform a Fun.ThrowingSupplier to an unchecked Supplier of the same supplied type parameter.
static <T,R> Function<T,R>	uncheck1(@NotNull Fun.ThrowingFunction<? super T,? extends R> mayThrowOnApply) Transform a Fun.ThrowingFunction to an unchecked Function of the same input and output type parameters.
static <K,V,R> BiFunction<K,V,R>	uncheck2(@NotNull Fun.ThrowingBiFunction<? super K,? super V,? extends R> mayThrowOnApply) Transform a Fun.ThrowingBiFunction to an unchecked BiFunction of the same input and output type parameters.
static <T> Predicate<T>	uncheckTest1(@NotNull Fun.ThrowingPredicate<? super T> mayThrowOnTest) Transform a Fun.ThrowingPredicate to a Predicate of the same input type parameter.
static <K,V> BiPredicate<K,V>	uncheckTest2(@NotNull Fun.ThrowingBiPredicate<? super K,? super V> mayThrowOnTest) Transform a Fun.ThrowingBiPredicate to a BiPredicate of the same input type parameter.
static <T> Consumer<T>	uncheckVoid1(@NotNull Fun.ThrowingConsumer<? super T> mayThrowOnAccept) Transform a Fun.ThrowingConsumer to a Consumer of the same input type parameter.
static <K,V> BiConsumer<K,V>	uncheckVoid2(@NotNull Fun.ThrowingBiConsumer<? super K,? super V> mayThrowOnAccept) Transform a Fun.ThrowingBiConsumer to a BiConsumer of the same input type parameter.
static <K,V> Function<K,Map.Entry<K,V>>	zipKeysWithValueFunc(@NotNull Function<? super K,? extends V> valueFunc) Zips stream elements into Map.Entry elements as keys, with values mapped from the provided function, which can, for example, be a Map.get(Object) method reference to perform a lookup.
static <K,V> Function<V,Map.Entry<K,V>>	zipValuesWithKeyFunc(@NotNull Function<? super V,? extends K> keyFunction) Zips stream elements into Map.Entry elements as values, with keys mapped from the provided function, which can, for example, be a Map.get(Object) method reference to perform a lookup.

Methods inherited from class java.lang.Object

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

Method Detail

streamIt

public static <T> Stream<T> streamIt(@Nullable
                                     T element)

What's the most efficient way to stream a single nullable element? I don't know, but maybe I randomly got it right under the hood.

Type Parameters:

T - the type of the element within the stream

Parameters:

element - the single element to stream

Returns:

a single-element stream

streamOpt

public static <T> Stream<T> streamOpt(@NotNull
                                      @NotNull Optional<T> element)

Use this to transform a less useful Optional into an equivalent single-element stream.

Type Parameters:

T - the type of the element within the stream

Parameters:

element - the single element to stream, wrapped in an Optional

Returns:

a single-element stream

tee

@NotNull
public static <T> @NotNull Function<T,T> tee(@NotNull
                                                      @NotNull Consumer<? super T> consumer)

Transform a consumer into a "tee" (like the Unix command, evoking the shape of the letter, 'T') function that passes the input argument to output after calling Consumer.accept(Object) with the input.

Type Parameters:

T - the input type

Parameters:

consumer - the consumer

Returns:

a tee function

constantly1

@NotNull
public static <T,R> @NotNull Function<T,R> constantly1(@NotNull
                                                                @NotNull Supplier<? extends R> supplier)

Fits a supplier into a pipeline as a constant Function.

Type Parameters:

T - the (ignored) input type

R - the supplied output type

Parameters:

supplier - the supplier

Returns:

a constant Function

constantly2

@NotNull
public static <K,V,R> @NotNull BiFunction<K,V,R> constantly2(@NotNull
                                                                      @NotNull Supplier<? extends R> supplier)

Fits a supplier into a pipeline as a constant BiFunction.

Type Parameters:

K - the (ignored) input entry key type

V - the (ignored) input entry value type

R - the supplied output type

Parameters:

supplier - the supplier

Returns:

a constant BiFunction

compose1

public static <T,I,R> Function<T,R> compose1(@NotNull
                                             @NotNull Function<T,? extends I> before,
                                             @NotNull
                                             @NotNull Function<? super I,? extends R> after)

Essentially the same as calling Function.andThen(Function), except needing no cast for a method reference as the before argument, resulting in function composition of before followed by after.

Type Parameters:

T - the input type

I - the intermediate type

R - the output type

Parameters:

before - the before function

after - the after function

Returns:

a composed Function

compose0

public static <R,S> Supplier<S> compose0(@NotNull
                                         @NotNull Supplier<? extends R> before,
                                         @NotNull
                                         @NotNull Function<? super R,? extends S> after)

Compose a Supplier with a Function that maps the original supplied type to a new supplied type.

Type Parameters:

R - the original supplied type

S - the new supplied type

Parameters:

before - the supplier

after - the after function

Returns:

a composed Supplier

compose2

public static <K,V,I,R> BiFunction<K,V,R> compose2(@NotNull
                                                   @NotNull BiFunction<K,V,? extends I> before,
                                                   @NotNull
                                                   @NotNull Function<? super I,? extends R> after)

Essentially the same as calling BiFunction.andThen(Function), except needing no cast for a method reference as the before argument, resulting in function composition of before followed by after.

Type Parameters:

K - the input stream entry key type

V - the input stream entry value type

I - the intermediate type

R - the output type

Parameters:

before - the before function

after - the after function

Returns:

a composed BiFunction

composeTest1

public static <T,P> Predicate<T> composeTest1(@NotNull
                                              @NotNull Function<? super T,? extends P> inputFunction,
                                              @NotNull
                                              @NotNull Predicate<? super P> testResult)

Compose a Predicate with a preceding input Function that maps the stream element type to the input type of the Predicate.

Type Parameters:

T - the pipeline element type

P - the original predicate input type

Parameters:

inputFunction - the preceding input function

testResult - the predicate

Returns:

a composed Predicate

composeTest2

public static <K,V,P,Q> BiPredicate<K,V> composeTest2(@NotNull
                                                      @NotNull Function<? super K,? extends P> inputTFunction,
                                                      @NotNull
                                                      @NotNull Function<? super V,? extends Q> inputUFunction,
                                                      @NotNull
                                                      @NotNull BiPredicate<? super P,? super Q> testResult)

Compose a BiPredicate with preceding left and right input Functions that map the stream Entry element key and value types to the respective input type of the provided BiPredicate.

Type Parameters:

K - the stream entry key type

V - the stream entry value type

P - the original predicate left input type

Q - the original predicate right input type

Parameters:

inputTFunction - the preceding left input function

inputUFunction - the preceding right input function

testResult - the predicate

Returns:

a composed BiPredicate

composeTest2

public static <K,V,P> BiPredicate<K,V> composeTest2(@NotNull
                                                    @NotNull BiFunction<? super K,? super V,? extends P> inputFunction,
                                                    @NotNull
                                                    @NotNull Predicate<? super P> testResult)

Compose a BiPredicate with a single preceding BiFunction that maps the stream Entry element key and value types to the input type of the provided Predicate.

Type Parameters:

K - the stream entry key type

V - the stream entry value type

P - the original predicate input type

Parameters:

inputFunction - the preceding input BiFunction

testResult - the predicate

Returns:

a composed BiPredicate

toVoid1

public static <T> Consumer<T> toVoid1(@NotNull
                                      @NotNull Function<? super T,?> inputFunction)

Infers a Function.apply(Object) signature as a Consumer.

Type Parameters:

T - the consumed input type

Parameters:

inputFunction - the Function to use as a Consumer

Returns:

a Consumer

toVoid2

public static <K,V> BiConsumer<K,V> toVoid2(@NotNull
                                            @NotNull BiFunction<? super K,? super V,?> inputFunction)

Infers a BiFunction.apply(Object, Object) signature as a BiConsumer.

Type Parameters:

K - the consumed stream entry key type

V - the consumed stream entry value type

Parameters:

inputFunction - the BiFunction to use as a BiConsumer

Returns:

a composed BiConsumer

infer1

public static <T,R> Function<T,R> infer1(@NotNull
                                         @NotNull Function<? super T,? extends R> methodRef)

Infers a static method ref to a Function.

Type Parameters:

T - the input type

R - the output type

Parameters:

methodRef - the method ref

Returns:

an inferred Function

infer2

public static <K,V,R> BiFunction<K,V,R> infer2(@NotNull
                                               @NotNull BiFunction<? super K,? super V,? extends R> methodRef)

Infers a static method ref to a BiFunction.

Type Parameters:

K - the input key type

V - the input value type

R - the return type

Parameters:

methodRef - the method ref

Returns:

an inferred BiFunction

infer0

public static <T> Supplier<T> infer0(@NotNull
                                     @NotNull Supplier<? extends T> methodRef)

Infers a method ref to a Supplier.

Type Parameters:

T - the supplied type

Parameters:

methodRef - the method ref

Returns:

an inferred Supplier

inferTest1

public static <T> Predicate<T> inferTest1(@NotNull
                                          @NotNull Predicate<? super T> methodRef)

Infers a method ref to a Predicate.

Type Parameters:

T - the input type

Parameters:

methodRef - the method ref

Returns:

an inferred Predicate

inferTest2

public static <K,V> BiPredicate<K,V> inferTest2(@NotNull
                                                @NotNull BiPredicate<? super K,? super V> methodRef)

Infers a method ref to a BiPredicate.

Type Parameters:

K - the input key type

V - the input value type

Parameters:

methodRef - the method ref

Returns:

an inferred BiPredicate

throwingVoidToNothing1

public static <T> Fun.ThrowingFunction<T,Nothing> throwingVoidToNothing1(@NotNull
                                                                         @NotNull Fun.ThrowingConsumer<? super T> mayThrowOnAccept)

Parallel method to Nothing.voidToNothing1(Consumer), for transforming a Fun.ThrowingConsumer to a Fun.ThrowingFunction that returns Nothing.

Type Parameters:

T - the consumed type

Parameters:

mayThrowOnAccept - the throwing consumer

Returns:

a Fun.ThrowingFunction that returns Nothing

throwingVoidToNothing2

public static <K,V> Fun.ThrowingBiFunction<K,V,Nothing> throwingVoidToNothing2(@NotNull
                                                                               @NotNull Fun.ThrowingBiConsumer<? super K,? super V> mayThrowOnAccept)

Parallel method to Nothing.voidToNothing2(BiConsumer), for transforming a Fun.ThrowingBiConsumer to a Fun.ThrowingBiFunction that returns Nothing.

Type Parameters:

K - the consumed key type

V - the consumed value type

Parameters:

mayThrowOnAccept - the throwing BiConsumer

Returns:

a Fun.ThrowingBiFunction that returns Nothing

entryTee

public static <K,V> Function<Map.Entry<K,V>,Map.Entry<K,V>> entryTee(@NotNull
                                                                     @NotNull BiConsumer<? super K,? super V> consumer)

Like tee(Consumer), this method transforms a BiConsumer into a "tee" (like the Unix command, evoking the shape of the letter, 'T') function for Map.Entry streams, that passes the input entry to output after calling BiConsumer.accept(Object, Object) with the input entry key and value.

Type Parameters:

K - the input entry key type

V - the input entry value type

Parameters:

consumer - the BiConsumer function

Returns:

a tee function for Map.Entry streams

zipKeysWithValueFunc

public static <K,V> Function<K,Map.Entry<K,V>> zipKeysWithValueFunc(@NotNull
                                                                    @NotNull Function<? super K,? extends V> valueFunc)

Zips stream elements into Map.Entry elements as keys, with values mapped from the provided function, which can, for example, be a Map.get(Object) method reference to perform a lookup.

Type Parameters:

K - the stream element and entry key type

V - the entry value type

Parameters:

valueFunc - the function to map a stream element as a key to an associated value for the constructed Map.Entry

Returns:

a function to map a stream element type to an entry with the same type for the key

zipValuesWithKeyFunc

public static <K,V> Function<V,Map.Entry<K,V>> zipValuesWithKeyFunc(@NotNull
                                                                    @NotNull Function<? super V,? extends K> keyFunction)

Zips stream elements into Map.Entry elements as values, with keys mapped from the provided function, which can, for example, be a Map.get(Object) method reference to perform a lookup.

Type Parameters:

K - the entry key type

V - the stream element and entry value type

Parameters:

keyFunction - the function to map a stream element as a value to an associated key for the constructed Map.Entry

Returns:

a function to map a stream element type to an entry with the same type for the value

toEntry

public static <K,V> Map.Entry<K,V> toEntry(@Nullable
                                           K key,
                                           @Nullable
                                           V value)

An alias for creating a AbstractMap.SimpleImmutableEntry for the provided key and value.

Type Parameters:

K - the entry key type

V - the entry value type

Parameters:

key - the entry key

value - the entry value

Returns:

an immutable Map.Entry

keepFirstMerger

public static <V> BinaryOperator<V> keepFirstMerger()

A merge function for entriesToMap(BinaryOperator) and entriesToMapOfType(Supplier, BinaryOperator) that keeps the first element defined for a key when merging duplicates.

Type Parameters:

V - the entry value type

Returns:

a merge function

keepLastMerger

public static <V> BinaryOperator<V> keepLastMerger()

A merge function for entriesToMap(BinaryOperator) and entriesToMapOfType(Supplier, BinaryOperator) that keeps the last element defined for a key when merging duplicates.

Type Parameters:

V - the entry value type

Returns:

a merge function

throwingMerger

public static <V> BinaryOperator<V> throwingMerger()

A merge function for entriesToMap(BinaryOperator) and entriesToMapOfType(Supplier, BinaryOperator) that throws an IllegalStateException when merging duplicates to guarantee distinct pairs.

Type Parameters:

V - the entry value type

Returns:

a merge function

entriesToMap

public static <K,V> Collector<Map.Entry<K,V>,?,Map<K,V>> entriesToMap()

Shorthand for Collectors.toMap(Function, Function) for collecting streams of Map.Entry, except using keepLastMerger() as the merge function, and LinkedHashMap as the supplied map type. This preserves stream sequence by default.

Type Parameters:

K - the entry key type

V - the entry value type

Returns:

a Map Collector for a stream of Map.Entry

entriesToMapOfType

public static <K,V> Collector<Map.Entry<K,V>,?,Map<K,V>> entriesToMapOfType(@NotNull
                                                                            @NotNull Supplier<Map<K,V>> mapSupplier)

Shorthand for Collectors.toMap(Function, Function, BinaryOperator, Supplier) for collecting streams of Map.Entry, except using keepLastMerger() as the merge function.

Type Parameters:

K - the entry key type

V - the entry value type

Parameters:

mapSupplier - a Map constructor method reference

Returns:

a Map Collector for a stream of Map.Entry

entriesToMap

public static <K,V> Collector<Map.Entry<K,V>,?,Map<K,V>> entriesToMap(@NotNull
                                                                      @NotNull BinaryOperator<V> mergeFunction)

Shorthand for Collectors.toMap(Function, Function, BinaryOperator, Supplier) for collecting streams of Map.Entry, except using LinkedHashMap as the supplied map type.

Type Parameters:

K - the entry key type

V - the entry value type

Parameters:

mergeFunction - a function to merge entry values on key duplication.

Returns:

a Map Collector for a stream of Map.Entry

See Also:

keepFirstMerger(), keepLastMerger(), throwingMerger()

entriesToMapOfType

public static <K,V> Collector<Map.Entry<K,V>,?,Map<K,V>> entriesToMapOfType(@NotNull
                                                                            @NotNull Supplier<Map<K,V>> mapSupplier,
                                                                            @NotNull
                                                                            @NotNull BinaryOperator<V> mergeFunction)

Shorthand for Collectors.toMap(Function, Function, BinaryOperator, Supplier) for collecting streams of Map.Entry.

Type Parameters:

K - the entry key type

V - the entry value type

Parameters:

mapSupplier - a Map constructor method reference

mergeFunction - a function to merge entry values on key duplication.

Returns:

a Map Collector for a stream of Map.Entry

See Also:

keepFirstMerger(), keepLastMerger(), throwingMerger()

mapEntry

public static <K,V,R> Function<Map.Entry<K,V>,R> mapEntry(@NotNull
                                                          @NotNull BiFunction<? super K,? super V,? extends R> biMapFunction)

Transform a BiFunction to a Function over Map.Entry stream elements of the same key and value type parameters.

Type Parameters:

K - the entry key type

V - the entry value type

R - the output type

Parameters:

biMapFunction - the mapping BiFunction

Returns:

a Function mapping over Map.Entry elements

mapValue

public static <K,V,W> Function<Map.Entry<K,V>,Map.Entry<K,W>> mapValue(@NotNull
                                                                       @NotNull BiFunction<? super K,? super V,? extends W> valueBiFunction)

Transform a BiFunction to a Function over Map.Entry stream elements of the same key and value type parameters, that returns new Map.Entry elements that retain the input key but take the output of the BiFunction as the new value.

Type Parameters:

K - the input and output entry key type

V - the input entry value type

W - the output entry value type

Parameters:

valueBiFunction - the mapping BiFunction

Returns:

a Function mapping over Map.Entry elements

mapValue

public static <K,V,W> Function<Map.Entry<K,V>,Map.Entry<K,W>> mapValue(@NotNull
                                                                       @NotNull Function<? super V,? extends W> valueFunction)

Transform a Function over value types to a Function over Map.Entry stream elements whose value type matches the input type of the Function, that returns new Map.Entry elements that retain the input key but take the output of the Function as the new value.

Type Parameters:

K - the input and output entry key type

V - the input entry value type

W - the output entry value type

Parameters:

valueFunction - the mapping Function

Returns:

a Function mapping over Map.Entry elements

mapKey

public static <K,V,L> Function<Map.Entry<K,V>,Map.Entry<L,V>> mapKey(@NotNull
                                                                     @NotNull BiFunction<? super K,? super V,? extends L> keyBiFunction)

Transform a BiFunction to a Function over Map.Entry stream elements of the same key and value type parameters, that returns new Map.Entry elements that retain the input value but take the output of the BiFunction as the new key.

Type Parameters:

K - the input entry key type

V - the input and output entry value type

L - the output entry key type

Parameters:

keyBiFunction - the mapping Function

Returns:

a Function mapping over Map.Entry elements

mapKey

public static <K,V,L> Function<Map.Entry<K,V>,Map.Entry<L,V>> mapKey(@NotNull
                                                                     @NotNull Function<? super K,? extends L> keyFunction)

Transform a Function over key types to a Function over Map.Entry stream elements whose key type matches the input type of the Function, that returns new Map.Entry elements that retain the input value but take the output of the Function as the new key.

Type Parameters:

K - the input entry key type

V - the input and output entry value type

L - the output entry key type

Parameters:

keyFunction - the mapping Function

Returns:

a Function mapping over Map.Entry elements

onEntry

public static <K,V> Consumer<Map.Entry<K,V>> onEntry(@NotNull
                                                     @NotNull BiConsumer<? super K,? super V> biConsumer)

Transform a BiConsumer to a Consumer of Map.Entry stream elements with matching respective key and value type parameters.

Type Parameters:

K - the stream entry key type

V - the stream entry value type

Parameters:

biConsumer - the BiConsumer

Returns:

a Consumer of Map.Entry

onKey

public static <K,V> Consumer<Map.Entry<K,V>> onKey(@NotNull
                                                   @NotNull Consumer<? super K> consumer)

Transform a Consumer of key types to a Consumer of Map.Entry stream elements with a matching key type parameter.

Type Parameters:

K - the input type and stream entry key type

V - the stream entry value type

Parameters:

consumer - the key consumer

Returns:

a Consumer of Map.Entry stream elements

onValue

public static <K,V> Consumer<Map.Entry<K,V>> onValue(@NotNull
                                                     @NotNull Consumer<? super V> consumer)

Transform a Consumer of value types to a Consumer of Map.Entry stream elements with a matching value type parameter.

Type Parameters:

K - the stream entry key type

V - the input type and stream entry value type

Parameters:

consumer - the key consumer

Returns:

a Consumer of Map.Entry stream elements

testEntry

public static <K,V> Predicate<? super Map.Entry<K,V>> testEntry(@NotNull
                                                                @NotNull BiPredicate<? super K,? super V> biPredicate)

Transform a BiPredicate to a Predicate testing Map.Entry stream elements with matching respective key and value type parameters.

Type Parameters:

K - the input key type

V - the input value type

Parameters:

biPredicate - the BiPredicate

Returns:

a Predicate filtering Map.Entry stream elements

testValue

public static <K,V> Predicate<? super Map.Entry<K,V>> testValue(@NotNull
                                                                @NotNull Predicate<? super V> valuePredicate)

Transform a Predicate of value types to a Predicate testing Map.Entry stream elements with a matching value type parameter.

Type Parameters:

K - the stream entry key type

V - the input type and stream entry value type

Parameters:

valuePredicate - the Predicate

Returns:

a Predicate filtering Map.Entry stream elements

testKey

public static <K,V> Predicate<? super Map.Entry<K,V>> testKey(@NotNull
                                                              @NotNull Predicate<? super K> keyPredicate)

Transform a Predicate of key types to a Predicate testing Map.Entry stream elements with a matching key type parameter.

Type Parameters:

K - the input value and stream entry key type

V - the stream entry value type

Parameters:

keyPredicate - the Predicate

Returns:

a Predicate filtering Map.Entry stream elements

inSet

public static <T,S extends Collection<? super T>> Predicate<T> inSet(@NotNull
                                                                     S haystack)

This method is used to support type inference around the Collection.contains(Object) method, whose argument is not otherwise typed with the element type parameter of the collection. This returns the method reference for the provided collection's contains method as a Predicate, but with restrictive type parameters so that it does not break inference by introducing Object as the input type bound.

Type Parameters:

T - the stream element type

S - the collection type wildcard

Parameters:

haystack - the collection possibly containing stream elements

Returns:

haystack::contains as a properly bounded predicate

isKeyIn

public static <K,M extends Map<? super K,?>> Predicate<K> isKeyIn(@NotNull
                                                                  M haystack)

This method is used to support type inference around the Map.containsKey(Object) method, whose argument is not otherwise typed with the key type parameter of the Map. This returns the method reference for the provided map's containsKey method as a Predicate, but with restrictive type parameters so that it does not break inference by introducing Object as the input type bound.

Type Parameters:

K - the stream element type

M - the map type wildcard

Parameters:

haystack - the map possibly containing stream elements as keys

Returns:

haystack::containsKey as a properly bounded predicate

isValueIn

public static <V,M extends Map<?,? super V>> Predicate<V> isValueIn(@NotNull
                                                                    M haystack)

This method is used to support type inference around the Map.containsValue(Object) method, whose argument is not otherwise typed with the value type parameter of the Map. This returns the method reference for the provided map's containsValue method as a Predicate, but with restrictive type parameters so that it does not break inference by introducing Object as the input type bound.

Type Parameters:

V - the stream element type

M - the map type wildcard

Parameters:

haystack - the map possibly containing stream elements as values

Returns:

haystack::containsValue as a properly bounded predicate

composeTry1

public static <M,T,R> Function<T,M> composeTry1(@NotNull
                                                @NotNull Function<? super R,? extends M> monadUnit,
                                                @NotNull
                                                @NotNull Supplier<? extends M> monadZero,
                                                @NotNull
                                                @NotNull Fun.ThrowingFunction<? super T,? extends R> mayThrowOnApply,
                                                @Nullable
                                                @Nullable BiConsumer<? super T,? super Exception> onError)

Composes four lambdas into a single function for use with flatMap() defined by Stream, Optional, etc. Useful for eliminating clumsy try/catch blocks from lambdas.

Type Parameters:

M - The captured monad type, which must match the return types of the monadUnit and monadZero functions, but which is not involved in the onElement or onError functions.

T - The input type mapped by the monoid/monad, i.e. the String type in Stream<String>.

R - The output type mapped by the monoid/monad, i.e. the URL type in Stream<URL>.

Parameters:

monadUnit - the "unit" (or "single") function defined by the appropriate monoid/monad. I.E. Stream::of, Optional::of, or Optional::ofNullable.

monadZero - the "zero" (or "empty") function defined by the appropriate monoid/monad, as in Stream::empty, or Optional::empty

mayThrowOnApply - some function that produces type R when applied to an input of type T, or fails with an Exception.

onError - an optional consumer function to perform some logic when the parser function throws. Receives both the failing input element and the caught Exception.

Returns:

a function that never throws an exception.

composeTry1

public static <M,T,R> Function<T,M> composeTry1(@NotNull
                                                @NotNull Function<? super R,? extends M> monoidSuccess,
                                                @NotNull
                                                @NotNull Function<? super Exception,? extends M> monoidError,
                                                @NotNull
                                                @NotNull Fun.ThrowingFunction<? super T,? extends R> mayThrowOnApply)

Composes four lambdas into a single function for use with flatMap() defined by Stream, Optional, etc. Useful for eliminating clumsy try/catch blocks from lambdas. This variation is geared towards use with Result or some other union type with an Exception constructor.

Type Parameters:

M - The captured monoid type, which must match the return types of the monoidSuccess and monoidError functions, but which is not involved in the mayThrowOnApply function.

T - The input type mapped by the monoid/monad, i.e. the String type in Stream<String>.

R - The output type mapped by the monoid/monad, i.e. the URL type in Stream<URL>.

Parameters:

monoidSuccess - the "successful" function defined by the appropriate monoid/monad. I.E. Result::success, Optional::of, or Optional::ofNullable.

monoidError - the "failure" function defined by the appropriate monoid/monad, as in Result::failure.

mayThrowOnApply - some function that produces type R when given an object of type T, or fails with an Exception.

Returns:

a function that returns a union type distinguishable between a result type and an error type

composeTry0

public static <M,R> Supplier<M> composeTry0(@NotNull
                                            @NotNull Function<? super R,? extends M> monadUnit,
                                            @NotNull
                                            @NotNull Supplier<? extends M> monadZero,
                                            @NotNull
                                            @NotNull Fun.ThrowingSupplier<? extends R> mayThrowOnGet,
                                            @Nullable
                                            @Nullable Consumer<? super Exception> onError)

Composes four lambdas into a single supplier for use with flatMap() defined by Stream, Optional, etc. Useful for eliminating clumsy try/catch blocks from lambdas.

Type Parameters:

M - The captured monad type, which must match the return types of the monadUnit and monadZero functions, but which is not involved in the onElement or onError functions.

R - The output type mapped by the monoid/monad, i.e. the URL type in Stream<URL>.

Parameters:

monadUnit - the "unit" (or "single") function defined by the appropriate monoid/monad. I.E. Stream::of, Optional::of, or Optional::ofNullable.

monadZero - the "zero" (or "empty") function defined by the appropriate monoid/monad, as in Stream::empty, or Optional::empty

mayThrowOnGet - some supplier that produces type R, or fails with an Exception.

onError - an optional consumer function to perform some logic when the parser function throws. Receives both the failing input element and the caught Exception.

Returns:

a supplier that never throws an exception.

composeTry0

public static <M,R> Supplier<M> composeTry0(@NotNull
                                            @NotNull Function<? super R,? extends M> monoidSuccess,
                                            @NotNull
                                            @NotNull Function<? super Exception,? extends M> monoidError,
                                            @NotNull
                                            @NotNull Fun.ThrowingSupplier<? extends R> mayThrowOnGet)

Composes four lambdas into a single supplier for use with flatMap() defined by Stream, Optional, etc. Useful for eliminating clumsy try/catch blocks from lambdas. This variation is geared towards use with Result or some other union type with an Exception constructor.

Type Parameters:

M - The captured monoid type, which must match the return types of the monoidSuccess and monoidError functions, but which is not involved in the mayThrowOnApply function.

R - The output type mapped by the monoid/monad, i.e. the URL type in Stream<URL>.

Parameters:

monoidSuccess - the "successful" function defined by the appropriate monoid/monad. I.E. Result::success, Optional::of, or Optional::ofNullable.

monoidError - the "failure" function defined by the appropriate monoid/monad, as in Result::failure.

mayThrowOnGet - some function that produces type R when given an object of type T, or fails with an Exception.

Returns:

a supplier that returns a union type distinguishable between a result type and an error type

composeTry2

public static <M,K,V,R> BiFunction<K,V,M> composeTry2(@NotNull
                                                      @NotNull Function<? super R,? extends M> monadUnit,
                                                      @NotNull
                                                      @NotNull Supplier<? extends M> monadZero,
                                                      @NotNull
                                                      @NotNull Fun.ThrowingBiFunction<? super K,? super V,? extends R> mayThrowOnApply,
                                                      @Nullable
                                                      @Nullable BiConsumer<? super Map.Entry<? super K,? super V>,? super Exception> onError)

Composes four lambdas into a single bifunction for use with flatMap() defined by Stream, Optional, etc. Useful for eliminating clumsy try/catch blocks from lambdas.

Type Parameters:

M - The captured monad type, which must match the return types of the monadUnit and monadZero functions, but which is not involved in the onElement or onError functions.

K - The left input type mapped by the function, i.e. the String type in Stream<String>.

V - The right input type mapped by the function, i.e. the String type in Stream<String>.

R - The output type mapped by the monoid/monad, i.e. the URL type in Stream<URL>.

Parameters:

monadUnit - the "unit" (or "single") function defined by the appropriate monoid/monad. I.E. Stream::of, Optional::of, or Optional::ofNullable.

monadZero - the "zero" (or "empty") function defined by the appropriate monoid/monad, as in Stream::empty, or Optional::empty

mayThrowOnApply - some function that produces type R when applied to inputs of type T and U, or fails with an Exception.

onError - an optional consumer function to perform some logic when the parser function throws. Receives both the failing input element and the caught Exception.

Returns:

a BiFunction that never throws an exception.

composeTry2

public static <M,K,V,R> BiFunction<K,V,M> composeTry2(@NotNull
                                                      @NotNull Function<? super R,? extends M> monoidSuccess,
                                                      @NotNull
                                                      @NotNull Function<? super Exception,? extends M> monoidError,
                                                      @NotNull
                                                      @NotNull Fun.ThrowingBiFunction<? super K,? super V,? extends R> mayThrowOnApply)

Composes four lambdas into a single function for use with flatMap() defined by Stream, Optional, etc. Useful for eliminating clumsy try/catch blocks from lambdas. This variation is geared towards use with Result or some other union type with an Exception constructor.

Type Parameters:

M - The captured monoid type, which must match the return types of the monoidSuccess and monoidError functions, but which is not involved in the mayThrowOnApply function.

K - The left input type mapped by the function

V - The right input type mapped by the function

R - The output type mapped by the monoid/monad, i.e. the URL type in Stream<URL>.

Parameters:

monoidSuccess - the "successful" function defined by the appropriate monoid/monad. I.E. Result::success, Optional::of, or Optional::ofNullable.

monoidError - the "failure" function defined by the appropriate monoid/monad, as in Result::failure.

mayThrowOnApply - some function that produces type R when given inputs of type T and U, or fails with an Exception.

Returns:

a function that returns a union type distinguishable between a result type and an error type

uncheck0

public static <R> Supplier<R> uncheck0(@NotNull
                                       @NotNull Fun.ThrowingSupplier<? extends R> mayThrowOnGet)

Transform a Fun.ThrowingSupplier to an unchecked Supplier of the same supplied type parameter. Exceptions will be caught and rethrown as Fun.FunRuntimeExceptions.

Type Parameters:

R - the supplied type

Parameters:

mayThrowOnGet - the ThrowingSupplier

Returns:

an unchecked Supplier

result0

public static <R> Supplier<Result<R>> result0(@NotNull
                                              @NotNull Fun.ThrowingSupplier<? extends R> mayThrowOnGet)

Transform a Fun.ThrowingSupplier to a Supplier of Result whose success type parameter is the same as the type parameter of the Fun.ThrowingSupplier.

Type Parameters:

R - the originally supplied type

Parameters:

mayThrowOnGet - the ThrowingSupplier

Returns:

a Supplier of Results of type R

uncheck1

public static <T,R> Function<T,R> uncheck1(@NotNull
                                           @NotNull Fun.ThrowingFunction<? super T,? extends R> mayThrowOnApply)

Transform a Fun.ThrowingFunction to an unchecked Function of the same input and output type parameters. Exceptions will be caught and rethrown as Fun.FunRuntimeExceptions.

Type Parameters:

T - the input type

R - the output type

Parameters:

mayThrowOnApply - the ThrowingFunction

Returns:

an unchecked Function

result1

public static <T,R> Function<T,Result<R>> result1(@NotNull
                                                  @NotNull Fun.ThrowingFunction<? super T,? extends R> mayThrowOnApply)

Transform a Fun.ThrowingFunction to a Function over the same input type parameter, which returns a Result whose success type parameter is the same as the output type of the Fun.ThrowingFunction.

Type Parameters:

T - the input type

R - the original output type

Parameters:

mayThrowOnApply - the ThrowingFunction

Returns:

a Function over the same input returning a Result of type R

uncheck2

public static <K,V,R> BiFunction<K,V,R> uncheck2(@NotNull
                                                 @NotNull Fun.ThrowingBiFunction<? super K,? super V,? extends R> mayThrowOnApply)

Transform a Fun.ThrowingBiFunction to an unchecked BiFunction of the same input and output type parameters. Exceptions will be caught and rethrown as Fun.FunRuntimeExceptions.

Type Parameters:

K - the input entry key type

V - the input entry value type

R - the output type

Parameters:

mayThrowOnApply - the ThrowingBiFunction

Returns:

an unchecked BiFunction

result2

public static <K,V,R> BiFunction<K,V,Result<R>> result2(@NotNull
                                                        @NotNull Fun.ThrowingBiFunction<? super K,? super V,? extends R> mayThrowOnApply)

Transform a Fun.ThrowingBiFunction to a BiFunction over the same input type parameters, which returns a Result whose success type parameter is the same as the output type of the Fun.ThrowingBiFunction.

Type Parameters:

K - the input entry key type

V - the input entry value type

R - the original output type

Parameters:

mayThrowOnApply - the ThrowingBiFunction

Returns:

a BiFunction over the same inputs returning a Result of type R

uncheckTest1

public static <T> Predicate<T> uncheckTest1(@NotNull
                                            @NotNull Fun.ThrowingPredicate<? super T> mayThrowOnTest)

Transform a Fun.ThrowingPredicate to a Predicate of the same input type parameter. Exceptions will be caught and rethrown as Fun.FunRuntimeExceptions.

Type Parameters:

T - the input type

Parameters:

mayThrowOnTest - the ThrowingPredicate

Returns:

an unchecked Predicate

uncheckTest2

public static <K,V> BiPredicate<K,V> uncheckTest2(@NotNull
                                                  @NotNull Fun.ThrowingBiPredicate<? super K,? super V> mayThrowOnTest)

Transform a Fun.ThrowingBiPredicate to a BiPredicate of the same input type parameter. Exceptions will be caught and rethrown as Fun.FunRuntimeExceptions.

Type Parameters:

K - the input entry key type

V - the input entry value type

Parameters:

mayThrowOnTest - the ThrowingBiPredicate

Returns:

an unchecked BiPredicate

uncheckVoid1

public static <T> Consumer<T> uncheckVoid1(@NotNull
                                           @NotNull Fun.ThrowingConsumer<? super T> mayThrowOnAccept)

Transform a Fun.ThrowingConsumer to a Consumer of the same input type parameter. Exceptions will be caught and rethrown as Fun.FunRuntimeExceptions.

Type Parameters:

T - the input type

Parameters:

mayThrowOnAccept - the ThrowingConsumer

Returns:

an unchecked Consumer

resultNothing1

public static <T> Function<T,Result<Nothing>> resultNothing1(@NotNull
                                                             @NotNull Fun.ThrowingConsumer<? super T> mayThrowOnAccept)

Transform a Fun.ThrowingConsumer to a Function over the same input type parameter, but which returns a Result of success type Nothing.

Type Parameters:

T - the input type

Parameters:

mayThrowOnAccept - the ThrowingConsumer

Returns:

a Function returning a Result of type Nothing

uncheckVoid2

public static <K,V> BiConsumer<K,V> uncheckVoid2(@NotNull
                                                 @NotNull Fun.ThrowingBiConsumer<? super K,? super V> mayThrowOnAccept)

Transform a Fun.ThrowingBiConsumer to a BiConsumer of the same input type parameter. Exceptions will be caught and rethrown as Fun.FunRuntimeExceptions.

Type Parameters:

K - the input entry key type

V - the input entry value type

Parameters:

mayThrowOnAccept - the ThrowingBiConsumer

Returns:

an unchecked BiConsumer

resultNothing2

public static <K,V> BiFunction<K,V,Result<Nothing>> resultNothing2(@NotNull
                                                                   @NotNull Fun.ThrowingBiConsumer<? super K,? super V> mayThrowOnAccept)

Transform a Fun.ThrowingBiConsumer to a BiFunction over the same input type parameters, but which returns a Result of success type Nothing.

Type Parameters:

K - the input entry key type

V - the input entry value type

Parameters:

mayThrowOnAccept - the ThrowingBiConsumer

Returns:

a BiFunction returning a Result of type Nothing

testOrDefault1

public static <T> Predicate<T> testOrDefault1(@NotNull
                                              @NotNull Fun.ThrowingPredicate<? super T> mayThrowOnTest,
                                              boolean defaultValue)

Transform a Fun.ThrowingPredicate to a Predicate, providing a default boolean value to return if an exception is thrown.

Type Parameters:

T - the input type

Parameters:

mayThrowOnTest - the ThrowingPredicate

defaultValue - the value to return when an exception is thrown

Returns:

a Predicate that returns a default value when an exception is thrown

testOrDefault2

public static <K,V> BiPredicate<K,V> testOrDefault2(@NotNull
                                                    @NotNull Fun.ThrowingBiPredicate<? super K,? super V> mayThrowOnTest,
                                                    boolean defaultValue)

Transform a Fun.ThrowingBiPredicate to a BiPredicate, providing a default boolean value to return if an exception is thrown.

Type Parameters:

K - the input entry key type

V - the input entry value type

Parameters:

mayThrowOnTest - the ThrowingBiPredicate

defaultValue - the value to return when an exception is thrown

Returns:

a BiPredicate that returns a default value when an exception is thrown

tryOrDefault0

public static <R> Supplier<R> tryOrDefault0(@NotNull
                                            @NotNull Fun.ThrowingSupplier<R> mayThrowOnGet,
                                            @Nullable
                                            R defaultValue)

Transform a Fun.ThrowingSupplier to a Supplier, providing a default value to return if an exception is thrown.

Type Parameters:

R - the supplied type

Parameters:

mayThrowOnGet - the ThrowingSupplier

defaultValue - the value to return when an exception is thrown

Returns:

a Supplier that supplies a default value when an exception is thrown

tryOrDefault1

public static <T,R> Function<T,R> tryOrDefault1(@NotNull
                                                @NotNull Fun.ThrowingFunction<? super T,R> mayThrowOnApply,
                                                @Nullable
                                                R defaultValue)

Transform a Fun.ThrowingFunction to a Function, providing a default value to return if an exception is thrown.

Type Parameters:

T - the input type

R - the output type

Parameters:

mayThrowOnApply - the ThrowingFunction

defaultValue - the value to return when an exception is thrown

Returns:

a Function that returns a default value when an exception is thrown

tryOrDefault2

public static <K,V,R> BiFunction<K,V,R> tryOrDefault2(@NotNull
                                                      @NotNull Fun.ThrowingBiFunction<? super K,? super V,R> mayThrowOnApply,
                                                      @Nullable
                                                      R defaultValue)

Transform a Fun.ThrowingBiFunction to a BiFunction, providing a default value to return if an exception is thrown.

Type Parameters:

K - the input entry key type

V - the input entry value type

R - the output type

Parameters:

mayThrowOnApply - the ThrowingBiFunction

defaultValue - the value to return when an exception is thrown

Returns:

a BiFunction that returns a default value when an exception is thrown

tryOrOptional0

public static <R> Supplier<Optional<R>> tryOrOptional0(@NotNull
                                                       @NotNull Fun.ThrowingSupplier<R> mayThrowOnGet)

Transform a Fun.ThrowingSupplier to a Supplier of the same type, wrapped in an Optional. The Optional value will be empty if an exception is thrown.

Type Parameters:

R - the originally supplied type

Parameters:

mayThrowOnGet - the ThrowingSupplier

Returns:

a Supplier that supplies an optional value that is empty if an exception is thrown

tryOrOptional1

public static <T,R> Function<T,Optional<R>> tryOrOptional1(@NotNull
                                                           @NotNull Fun.ThrowingFunction<? super T,R> mayThrowOnApply)

Transform a Fun.ThrowingFunction to a Function of the same input type, with the output type wrapped in an Optional. The Optional value will be empty if an exception is thrown.

Type Parameters:

T - the input type

R - the original output type

Parameters:

mayThrowOnApply - the ThrowingFunction

Returns:

a Function that returns an optional value that is empty if an exception is thrown

tryOrOptional2

public static <K,V,R> BiFunction<K,V,Optional<R>> tryOrOptional2(@NotNull
                                                                 @NotNull Fun.ThrowingBiFunction<? super K,? super V,R> mayThrowOnApply)

Transform a Fun.ThrowingBiFunction to a BiFunction of the same input types, with the output type wrapped in an Optional. The Optional value will be empty if an exception is thrown.

Type Parameters:

K - the input entry key type

V - the input entry value type

R - the original output type

Parameters:

mayThrowOnApply - the ThrowingBiFunction

Returns:

a BiFunction that returns an optional value that is empty if an exception is thrown

tryOrVoid1

public static <T> Consumer<T> tryOrVoid1(@NotNull
                                         @NotNull Fun.ThrowingConsumer<? super T> mayThrowOnAccept)

Transform a Fun.ThrowingConsumer to a Consumer of the same input type, that simply suppresses any exceptions if thrown.

Type Parameters:

T - the input type

Parameters:

mayThrowOnAccept - the ThrowingConsumer

Returns:

a Consumer that suppresses any exceptions if thrown

tryOrVoid2

public static <K,V> BiConsumer<K,V> tryOrVoid2(@NotNull
                                               @NotNull Fun.ThrowingBiConsumer<? super K,? super V> mayThrowOnAccept)

Transform a Fun.ThrowingBiConsumer to a BiConsumer of the same input types, that simply suppresses any exceptions if thrown.

Type Parameters:

K - the input entry key type

V - the input entry value type

Parameters:

mayThrowOnAccept - the ThrowingBiConsumer

Returns:

a Consumer that suppresses any exceptions if thrown