Functions (reactive4java 0.98.0 API)

java.lang.Object
- hu.akarnokd.reactive4java.util.Functions

public final class Functions
extends java.lang.Object

Helper class with function types.

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.Runnable`	`EMPTY_RUNNABLE` An empty runnable.
`static Pred0`	`FALSE` Constant parameterless function which returns always false.
`static Func1<java.lang.Integer,java.lang.Long>`	`INT_TO_LONG` Casts an integer value to long.
`static Func1<java.lang.Long,java.lang.Integer>`	`LONG_TO_INT` Converts a long to integer, ignoring any overflow or underflow.
`static Func1<java.lang.Long,java.lang.Integer>`	`LONG_TO_INT_CHECKED` Converts a long to integer or throws an ArithmeticException if overflow or underflow happens.
`static Pred0`	`TRUE` Constant parameterless function which returns always true.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> Pred1<T>`	`alwaysFalse1()` Returns a function which always returns false regardless of its parameters.
`static <T,U> Pred2<T,U>`	`alwaysFalse2()` Returns a function which always returns false regardless of its parameters.
`static <T> Pred1<T>`	`alwaysTrue1()` Returns a function which always returns true regardless of its parameters.
`static <T,U> Pred2<T,U>`	`alwaysTrue2()` Returns a function which always returns true regardless of its parameters.
`static Func2<java.lang.Boolean,java.lang.Boolean,java.lang.Boolean>`	`and()`
`static Func0<java.lang.Boolean>`	`and(Func0<java.lang.Boolean> f1, Func0<java.lang.Boolean> f2)` Returns a function which takes the logical AND of the given two functions when invoked.
`static <T> Func1<T,java.lang.Boolean>`	`and(Func1<? super T,java.lang.Boolean> f1, Func1<? super T,java.lang.Boolean> f2)` Returns a function which takes the logical AND of the given two functions when invoked.
`static <T,U> Func2<T,U,java.lang.Boolean>`	`and(Func2<? super T,? super U,java.lang.Boolean> f1, Func2<? super T,? super U,java.lang.Boolean> f2)` Returns a function which takes the logical AND of the given two functions when invoked.
`static <T> Func0<java.util.ArrayList<T>>`	`arrayListProvider()` A list creator factory.
`static <T,U> Func1<U,java.util.ArrayList<T>>`	`arrayListProvider1()` A list creator factory for Func1 that ignores the parameter.
`static <T> java.util.concurrent.Callable<T>`	`asCallable(Func0<? extends T> func)` Wraps the given Func0 object into a callable instance.
`static <T> java.util.Comparator<T>`	`asComparator(Func2<? super T,? super T,java.lang.Integer> func)` Wrap the given two argument function returning an integer as a comparator.
`static Func1<java.lang.Integer,java.lang.Double>`	`asDoubleFunc1(java.util.List<? extends java.lang.Number> values)` Wrap the given list of number into a function which returns the `param1` element as double.
`static <T> Func0<T>`	`asFunc0(Action0 action, T result)` Wraps the given action into a function which calls the action and then returns the `result` value.
`static Func0<java.lang.Boolean>`	`asFunc0(java.util.concurrent.atomic.AtomicBoolean source)` Wraps the given atomic boolean and returns its value.
`static Func0<java.lang.Integer>`	`asFunc0(java.util.concurrent.atomic.AtomicInteger source)` Wraps the given atomic integer object and returns its value.
`static Func0<java.lang.Long>`	`asFunc0(java.util.concurrent.atomic.AtomicLong source)` Wraps the given atomic integer object and returns its value.
`static <T> Func0<T>`	`asFunc0(java.util.concurrent.atomic.AtomicReference<? extends T> source)` Wraps the given atomic reference object and returns its value.
`static <T> Func0<T>`	`asFunc0(java.util.concurrent.Callable<? extends T> call)` Wraps the given Callable function into a Func0 object.
`static <T> Func0<T>`	`asFunc0(java.lang.ref.Reference<? extends T> ref)` Wrap the given reference into a function.
`static <T> Func0<T>`	`asFunc0(java.lang.Runnable action, T result)` Wraps the given Runnable into a function which calls the action and then returns the `result` value.
`static <T,U> Func1<T,U>`	`asFunc1(Action0 action, U result)` Wraps the given action into a function which calls the action and then returns the `result` value.
`static <T,U> Func1<T,U>`	`asFunc1(Action1<? super T> action, U result)` Wraps the given action into a function which calls the action and then returns the `result` value.
`static <T,U> Func1<T,U>`	`asFunc1(java.util.concurrent.Callable<? extends U> call)` Wraps the given callable function into a 1 parameter function.
`static Func1<java.lang.Integer,java.lang.Double>`	`asFunc1(double... values)` Wrap the given one dimensional array into a function which returns the `param1` element.
`static <T,U> Func1<T,U>`	`asFunc1(Func0<? extends U> f)` Wraps the given zero parameter function into a 1 parameter function which ignores its parameter.
`static Func1<java.lang.Integer,java.lang.Integer>`	`asFunc1(int... values)` Wrap the given one dimensional array into a function which returns the `param1` element.
`static <T> Func1<java.lang.Integer,T>`	`asFunc1(java.util.List<? extends T> values)` Wrap the given list into a function which returns the `param1` element.
`static Func1<java.lang.Integer,java.lang.Long>`	`asFunc1(long... values)` Wrap the given one dimensional array into a function which returns the `param1` element.
`static <K,V> Func1<K,V>`	`asFunc1(java.util.Map<? super K,? extends V> map)` Creates a single parameter function which returns values from the given map.
`static <T,U> Func1<T,U>`	`asFunc1(java.lang.Runnable action, U result)` Wraps the given Runnable into a function which calls the action and then returns the `result` value.
`static <K> Func1<K,java.lang.Boolean>`	`asFunc1(java.util.Set<? super K> set)` Creates a single parameter predicate function which returns true if the supplied parameter is in the given collection.
`static <T,U,V> Func2<T,U,V>`	`asFunc2(Action0 action, V value)` Wraps the given action into a 2 parameter function which returns the supplied value.
`static <T,U,V> Func2<T,U,V>`	`asFunc2(Action2<? super T,? super U> action, V result)` Wraps the given action into a function which calls the action and then returns the `result` value.
`static <T,U,V> Func2<T,U,V>`	`asFunc2(java.util.concurrent.Callable<? extends V> call)` Wraps the given callable function into a 2 parameter function.
`static <T> Func2<T,T,java.lang.Integer>`	`asFunc2(java.util.Comparator<? super T> comparator)` Wrap the given comparator function into a function object.
`static Func2<java.lang.Integer,java.lang.Integer,java.lang.Double>`	`asFunc2(double[][] values)` Wrap the given two dimensional array into a function which returns the `param1, param2` element.
`static <T,U,V> Func2<T,U,V>`	`asFunc2(Func0<? extends V> f)` Wraps the given zero parameter function into a 2 parameter function which ignores its parameters.
`static Func2<java.lang.Integer,java.lang.Integer,java.lang.Integer>`	`asFunc2(int[][] values)` Wrap the given two dimensional array into a function which returns the `param1, param2` element.
`static Func2<java.lang.Integer,java.lang.Integer,java.lang.Long>`	`asFunc2(long[][] values)` Wrap the given two dimensional array into a function which returns the `param1, param2` element.
`static <K1,K2,V> Func2<K1,K2,V>`	`asFunc2(java.util.Map<? super K1,? extends java.util.Map<? super K2,? extends V>> map)` Wraps a two-layer (map of map of something) into a two parameter function.
`static <T,U,V> Func2<T,U,V>`	`asFunc2(java.lang.Runnable action, V value)` Wraps the given Runnable into a 2 parameter function which returns the supplied value.
`static <T> Func2<java.lang.Integer,java.lang.Integer,T>`	`asFunc2(T[][] values)` Wrap the given two dimensional array into a function which returns the `param1, param2` element.
`static Func1<java.lang.Integer,java.lang.Integer>`	`asIntFunc1(java.util.List<? extends java.lang.Number> values)` Wrap the given list of number into a function which returns the `param1` element as int.
`static Func1<java.lang.Integer,java.lang.Long>`	`asLongFunc1(java.util.List<? extends java.lang.Number> values)` Wrap the given list of number into a function which returns the `param1` element as long.
`static <T extends java.lang.Comparable<? super T>> java.util.Comparator<T>`	`comparator()` Returns a convenience comparator which basically compares objects which implement the `Comparable` interface.
`static <T extends java.lang.Comparable<? super T>> java.util.Comparator<T>`	`comparator0()` Returns a convenience comparator which basically compares objects which implement the `Comparable` interface.
`static <T extends java.lang.Comparable<? super T>> java.util.Comparator<T>`	`comparatorReverse()` Creates a new comparator which reverses the order of the comparison.
`static <T> java.util.Comparator<T>`	`comparatorReverse(java.util.Comparator<? super T> normal)` Creates a new comparator which reverses the order produced by the given normal comparator.
`static <K,V> Func0<java.util.concurrent.ConcurrentHashMap<K,V>>`	`concurrentHashMapProvider()` A map creator factory.
`static <Param1,Result> Func1<Param1,Result>`	`constant(Result value)` Creates a function which returns always the same value.
`static <T> Func0<T>`	`constant0(T value)` Creates a function which returns always the same value.
`static <T,U,V> Func2<T,U,V>`	`constant2(V value)` Creates a constant function which always returns the given value regardless of the parameters.
`static Func1<java.math.BigInteger,java.math.BigInteger>`	`decrementBigInteger()`
`static Func1<java.lang.Integer,java.lang.Integer>`	`decrementInt()`
`static Func1<java.lang.Long,java.lang.Long>`	`decrementLong()`
`static <T> Func1<T,java.lang.Boolean>`	`equal(T value)` Returns a function which returns true if its submitted parameter value equals to the given constant.
`static <T> Func2<T,T,java.lang.Boolean>`	`equals()` Returns a function which compares its two parameters by a null-safe equals.
`static <T extends java.lang.Comparable<? super T>> Func1<T,java.lang.Boolean>`	`greaterOrEqual(T value)` Create a function which returns true for submitted values greater or equal than the given value.
`static <T> Func1<T,java.lang.Boolean>`	`greaterOrEqual(T value, java.util.Comparator<? super T> comparator)` Returns a function which returns true if the function parameter is greater or equal to the constant in respect to the supplied comparator.
`static <T extends java.lang.Comparable<? super T>> Func1<T,java.lang.Boolean>`	`greaterThan(T value)` Create a function which returns true for submitted values greater than the given value.
`static <T> Func1<T,java.lang.Boolean>`	`greaterThan(T value, java.util.Comparator<? super T> comparator)` Returns a function which returns true if the function parameter is greater than the constant in respect to the supplied comparator.
`static <K,V> Func0<java.util.HashMap<K,V>>`	`hashMapProvider()` A map creator factory.
`static <T> Func0<java.util.HashSet<T>>`	`hashSetProvider()` A set creation provider.
`static <T> Func1<T,T>`	`identity()` Returns a function which returns its parameter value.
`static <T,U> Func2<T,U,T>`	`identityFirst()` Returns a helper function of two parameters which always returns its first parameter.
`static <T,U> Func2<T,U,U>`	`identitySecond()` Returns a helper function of two parameters which always returns its second parameter.
`static Func1<java.math.BigInteger,java.math.BigInteger>`	`incrementBigInteger()`
`static Func1<java.lang.Integer,java.lang.Integer>`	`incrementBy(int value)` Returns a function which increments its parameter by the given amount.
`static Func1<java.lang.Long,java.lang.Long>`	`incrementBy(long value)` Returns a function which increments its parameter by the given amount.
`static Func1<java.lang.Integer,java.lang.Integer>`	`incrementInt()`
`static Func1<java.lang.Long,java.lang.Long>`	`incrementLong()`
`static <T extends java.lang.Comparable<? super T>> Func1<T,java.lang.Boolean>`	`lessOrEqual(T value)` Create a function which returns true for submitted values less or equal than the given value.
`static <T> Func1<T,java.lang.Boolean>`	`lessOrEqual(T value, java.util.Comparator<? super T> comparator)` Create a function which returns true for submitted values less or equal than the given value in respect to the supplied comparator.
`static <T extends java.lang.Comparable<? super T>> Func1<T,java.lang.Boolean>`	`lessThan(T value)` Create a function which returns true for submitted values less than the given value.
`static <T> Func1<T,java.lang.Boolean>`	`lessThan(T value, java.util.Comparator<? super T> comparator)` Create a function which returns true for submitted values less than the given value in respect to the supplied comparator.
`static <K,V> Func0<java.util.LinkedHashMap<K,V>>`	`linkedHashMapProvider()` A map creator factory.
`static <T> Func0<java.util.LinkedList<T>>`	`linkedListProvider()` A list creator factory.
`static <T extends java.lang.Comparable<? super T>> Func2<T,T,T>`	`max()` Returns a function which returns the greater of its parameters.
`static <T> Func2<T,T,T>`	`max(java.util.Comparator<? super T> comparator)` Returns a function which returns the greater of its parameters in respect to the supplied `Comparator`.
`static <T extends java.lang.Comparable<? super T>> Func2<T,T,T>`	`min()` Returns a function which returns the smaller of its parameters.
`static <T> Func2<T,T,T>`	`min(java.util.Comparator<? super T> comparator)` Returns a function which returns the smaller of its parameters in respect to the supplied `Comparator`.
`static Func1<java.lang.Boolean,java.lang.Boolean>`	`negate()`
`static Func0<java.lang.Boolean>`	`not(Func0<java.lang.Boolean> func)` Creates a function which negates the supplied function's value.
`static <T> Func1<T,java.lang.Boolean>`	`not(Func1<? super T,java.lang.Boolean> f)` Returns a function which creates the logical not of the wrapped function value for value t:T.
`static <T,U> Func2<T,U,java.lang.Boolean>`	`not(Func2<? super T,? super U,java.lang.Boolean> f)` Returns a function which creates the logical not of the wrapped function value for value t:T and u:U.
`static <T> Func1<T,java.lang.Boolean>`	`notEqual(T value)` Returns a function which returns true if its sumbitted parameter value does not equal to the given constant.
`static Func2<java.lang.Boolean,java.lang.Boolean,java.lang.Boolean>`	`or()`
`static Func0<java.lang.Boolean>`	`or(Func0<java.lang.Boolean> f1, Func0<java.lang.Boolean> f2)` Returns a function which takes the logical OR of the given two functions when invoked.
`static <T> Func1<T,java.lang.Boolean>`	`or(Func1<? super T,java.lang.Boolean> f1, Func1<? super T,java.lang.Boolean> f2)` Returns a function which takes the logical OR of the given two functions when invoked.
`static <T,U> Func2<T,U,java.lang.Boolean>`	`or(Func2<? super T,? super U,java.lang.Boolean> f1, Func2<? super T,? super U,java.lang.Boolean> f2)` Returns a function which takes the logical OR of the given two functions when invoked.
`static <T,U> Func2<T,U,Pair<T,U>>`	`pairUp()`
`static Func2<java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal>`	`sumBigDecimal()` Retuns a function that adds two BigDecimal numbers and returns a new one.
`static Func2<java.math.BigInteger,java.math.BigInteger,java.math.BigInteger>`	`sumBigInteger()` Retuns a function that adds two BigInteger numbers and returns a new one.
`static Func2<java.lang.Double,java.lang.Double,java.lang.Double>`	`sumDouble()` Retuns a function that adds two Double number and returns a new one.
`static Func2<java.lang.Float,java.lang.Float,java.lang.Float>`	`sumFloat()` Retuns a function that adds two Float number and returns a new one.
`static Func2<java.lang.Integer,java.lang.Integer,java.lang.Integer>`	`sumInteger()` Retuns a function that adds two Integer number and returns a new one.
`static Func2<java.lang.Long,java.lang.Long,java.lang.Long>`	`sumLong()` Retuns a function that adds two Long number and returns a new one.
`static <T,U,V> Func2<T,U,V>`	`swap(Func2<U,T,V> func)` Returns a function which calls the supplied function with swapped parameter order.
`static <K,V> Func0<java.util.TreeMap<K,V>>`	`treeMapProvider()` A map creator factory.
`static <K,V> Func0<java.util.TreeMap<K,V>>`	`treeMapProvider(java.util.Comparator<? super K> keyComparator)` A map creator factory.
`static <T> Func0<java.util.TreeSet<T>>`	`treeSetProvider()` A set creation provider.
`static <T> Func0<java.util.TreeSet<T>>`	`treeSetProvider(java.util.Comparator<? super T> elementComparator)` A set creation provider.
`static Func0<java.lang.Boolean>`	`xor(Func0<java.lang.Boolean> f1, Func0<java.lang.Boolean> f2)` Returns a function which takes the logical XOR of the given two functions when invoked.
`static <T> Func1<T,java.lang.Boolean>`	`xor(Func1<? super T,java.lang.Boolean> f1, Func1<? super T,java.lang.Boolean> f2)` Returns a function which takes the logical XOR of the given two functions when invoked.
`static <T,U> Func2<T,U,java.lang.Boolean>`	`xor(Func2<? super T,? super U,java.lang.Boolean> f1, Func2<? super T,? super U,java.lang.Boolean> f2)` Returns a function which takes the logical XOR of the given two functions when invoked.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - FALSE
```
@Nonnull
public static final Pred0 FALSE
```
    Constant parameterless function which returns always false.
  - TRUE
```
@Nonnull
public static final Pred0 TRUE
```
    Constant parameterless function which returns always true.
  - EMPTY_RUNNABLE
```
@Nonnull
public static final java.lang.Runnable EMPTY_RUNNABLE
```
    An empty runnable.
  - INT_TO_LONG
```
public static final Func1<java.lang.Integer,java.lang.Long> INT_TO_LONG
```
    Casts an integer value to long.
    
    Since:
    
    0.97
    
    See Also:
    
    LONG_TO_INT_CHECKED, LONG_TO_INT
  - LONG_TO_INT_CHECKED
```
public static final Func1<java.lang.Long,java.lang.Integer> LONG_TO_INT_CHECKED
```
    Converts a long to integer or throws an ArithmeticException if overflow or underflow happens.
    
    Since:
    
    0.97
    
    See Also:
    
    LONG_TO_INT, INT_TO_LONG
  - LONG_TO_INT
```
public static final Func1<java.lang.Long,java.lang.Integer> LONG_TO_INT
```
    Converts a long to integer, ignoring any overflow or underflow.
    
    Since:
    
    0.97
    
    See Also:
    
    LONG_TO_INT_CHECKED, INT_TO_LONG
- Method Detail
  - alwaysFalse1
```
@Nonnull
public static <T> Pred1<T> alwaysFalse1()
```
    Returns a function which always returns false regardless of its parameters.
    
    Type Parameters:
    
    T - the type of the parameter (irrelevant)
    
    Returns:
    
    the function which returns always false
  - alwaysTrue1
```
@Nonnull
public static <T> Pred1<T> alwaysTrue1()
```
    Returns a function which always returns true regardless of its parameters.
    
    Type Parameters:
    
    T - the type of the parameter (irrelevant)
    
    Returns:
    
    the function which returns always true
  - alwaysFalse2
```
@Nonnull
public static <T,U> Pred2<T,U> alwaysFalse2()
```
    Returns a function which always returns false regardless of its parameters.
    
    Type Parameters:
    
    T - the type of the parameter (irrelevant)
    
    U - the type of the parameter (irrelevant)
    
    Returns:
    
    the function which returns always false
  - alwaysTrue2
```
@Nonnull
public static <T,U> Pred2<T,U> alwaysTrue2()
```
    Returns a function which always returns true regardless of its parameters.
    
    Type Parameters:
    
    T - the type of the parameter (irrelevant)
    
    U - the type of the parameter (irrelevant)
    
    Returns:
    
    the function which returns always true
  - asCallable
```
@Nonnull
public static <T> java.util.concurrent.Callable<T> asCallable(@Nonnull
                                                                        Func0<? extends T> func)
```
    Wraps the given Func0 object into a callable instance.
    
    Type Parameters:
    
    T - the return type
    
    Parameters:
    
    func - the function to wrap
    
    Returns:
    
    the callable wrapper
  - asComparator
```
@Nonnull
public static <T> java.util.Comparator<T> asComparator(@Nonnull
                                                                 Func2<? super T,? super T,java.lang.Integer> func)
```
    Wrap the given two argument function returning an integer as a comparator.
    
    Type Parameters:
    
    T - the type of the elements to compare
    
    Parameters:
    
    func - the function to wrap
    
    Returns:
    
    the comparator
  - asFunc0
```
@Nonnull
public static <T> Func0<T> asFunc0(@Nonnull
                                             Action0 action,
                                             T result)
```
    Wraps the given action into a function which calls the action and then returns the result value.
    
    Type Parameters:
    
    T - the result type
    
    Parameters:
    
    action - the action to invoke
    
    result - the result to present after the action invocation
    
    Returns:
    
    the function
  - asFunc1
```
@Nonnull
public static <T,U> Func1<T,U> asFunc1(@Nonnull
                                                 Action1<? super T> action,
                                                 U result)
```
    Wraps the given action into a function which calls the action and then returns the result value.
    
    Type Parameters:
    
    T - the parameter type
    
    U - the result type
    
    Parameters:
    
    action - the action to invoke
    
    result - the result to present after the action invocation
    
    Returns:
    
    the function
  - asFunc2
```
@Nonnull
public static <T,U,V> Func2<T,U,V> asFunc2(@Nonnull
                                                     Action2<? super T,? super U> action,
                                                     V result)
```
    Wraps the given action into a function which calls the action and then returns the result value.
    
    Type Parameters:
    
    T - the first parameter type
    
    U - the second parameter type
    
    V - the result type
    
    Parameters:
    
    action - the action to invoke
    
    result - the result to present after the action invocation
    
    Returns:
    
    the function
  - asFunc0
```
@Nonnull
public static <T> Func0<T> asFunc0(@Nonnull
                                             java.util.concurrent.Callable<? extends T> call)
```
    Wraps the given Callable function into a Func0 object.
    
    Type Parameters:
    
    T - the return type of the function
    
    Parameters:
    
    call - the original call function
    
    Returns:
    
    the Func0 function wrapping the call
  - asFunc2
```
@Nonnull
public static <T> Func2<T,T,java.lang.Integer> asFunc2(@Nonnull
                                                                 java.util.Comparator<? super T> comparator)
```
    Wrap the given comparator function into a function object.
    
    Type Parameters:
    
    T - the type of elements to compare
    
    Parameters:
    
    comparator - the comparator
    
    Returns:
    
    the wrapped comparator
  - asFunc0
```
@Nonnull
public static Func0<java.lang.Boolean> asFunc0(@Nonnull
                                                         java.util.concurrent.atomic.AtomicBoolean source)
```
    Wraps the given atomic boolean and returns its value.
    
    Parameters:
    
    source - the source atomic reference
    
    Returns:
    
    the function
  - asFunc0
```
@Nonnull
public static Func0<java.lang.Integer> asFunc0(@Nonnull
                                                         java.util.concurrent.atomic.AtomicInteger source)
```
    Wraps the given atomic integer object and returns its value.
    
    Parameters:
    
    source - the source atomic reference
    
    Returns:
    
    the function
  - asFunc0
```
@Nonnull
public static Func0<java.lang.Long> asFunc0(@Nonnull
                                                      java.util.concurrent.atomic.AtomicLong source)
```
    Wraps the given atomic integer object and returns its value.
    
    Parameters:
    
    source - the source atomic reference
    
    Returns:
    
    the function
  - asFunc0
```
@Nonnull
public static <T> Func0<T> asFunc0(@Nonnull
                                             java.util.concurrent.atomic.AtomicReference<? extends T> source)
```
    Wraps the given atomic reference object and returns its value.
    
    Type Parameters:
    
    T - the type of the contained object
    
    Parameters:
    
    source - the source atomic reference
    
    Returns:
    
    the function
  - comparator
```
@Nonnull
public static <T extends java.lang.Comparable<? super T>> java.util.Comparator<T> comparator()
```
    Returns a convenience comparator which basically compares objects which implement the Comparable interface. The comparator is null safe in the manner, that nulls are always less than any non-nulls. To have a comparator which places nulls last, use the comparator0() method.
    
    Type Parameters:
    
    T - the element types to compare
    
    Returns:
    
    the comparator
    
    See Also:
    
    comparator0()
  - comparator0
```
@Nonnull
public static <T extends java.lang.Comparable<? super T>> java.util.Comparator<T> comparator0()
```
    Returns a convenience comparator which basically compares objects which implement the Comparable interface. The comparator is null safe in the manner, that nulls are always greater than any non-nulls. To have a comparator which places nulls first, use the comparator() method.
    
    Type Parameters:
    
    T - the element types to compare
    
    Returns:
    
    the comparator
  - comparatorReverse
```
@Nonnull
public static <T extends java.lang.Comparable<? super T>> java.util.Comparator<T> comparatorReverse()
```
    Creates a new comparator which reverses the order of the comparison.
    
    Type Parameters:
    
    T - the element type, which must be self comparable
    
    Returns:
    
    the new comparator
  - comparatorReverse
```
@Nonnull
public static <T> java.util.Comparator<T> comparatorReverse(@Nonnull
                                                                      java.util.Comparator<? super T> normal)
```
    Creates a new comparator which reverses the order produced by the given normal comparator.
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    normal - the normal comparator
    
    Returns:
    
    the new comparator
  - constant
```
@Nonnull
public static <Param1,Result> Func1<Param1,Result> constant(Result value)
```
    Creates a function which returns always the same value.
    
    Type Parameters:
    
    Param1 - the parameter type, irrelevant
    
    Result - the value type to return
    
    Parameters:
    
    value - the value to return
    
    Returns:
    
    the function
  - constant0
```
@Nonnull
public static <T> Func0<T> constant0(T value)
```
    Creates a function which returns always the same value.
    
    Type Parameters:
    
    T - the value type to return
    
    Parameters:
    
    value - the value to return
    
    Returns:
    
    the function
  - decrementBigInteger
```
@Nonnull
public static Func1<java.math.BigInteger,java.math.BigInteger> decrementBigInteger()
```
    Returns:
    
    a function which returns param - 1 for BigIntegers.
  - decrementInt
```
@Nonnull
public static Func1<java.lang.Integer,java.lang.Integer> decrementInt()
```
    Returns:
    
    a function which returns param - 1 for Integers.
  - decrementLong
```
@Nonnull
public static Func1<java.lang.Long,java.lang.Long> decrementLong()
```
    Returns:
    
    a function which returns param + 1 for Longs.
  - equal
```
@Nonnull
public static <T> Func1<T,java.lang.Boolean> equal(T value)
```
    Returns a function which returns true if its submitted parameter value equals to the given constant.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    value - the value
    
    Returns:
    
    the function
  - greaterOrEqual
```
@Nonnull
public static <T extends java.lang.Comparable<? super T>> Func1<T,java.lang.Boolean> greaterOrEqual(@Nonnull
                                                                                                              T value)
```
    Create a function which returns true for submitted values greater or equal than the given value.
    
    Type Parameters:
    
    T - a type which is comparable with itself
    
    Parameters:
    
    value - constant to compare against
    
    Returns:
    
    the function
  - greaterOrEqual
```
@Nonnull
public static <T> Func1<T,java.lang.Boolean> greaterOrEqual(@Nonnull
                                                                      T value,
                                                                      @Nonnull
                                                                      java.util.Comparator<? super T> comparator)
```
    Returns a function which returns true if the function parameter is greater or equal to the constant in respect to the supplied comparator.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    value - constant to compare against
    
    comparator - the comparator for Ts.
    
    Returns:
    
    the function
  - greaterThan
```
@Nonnull
public static <T extends java.lang.Comparable<? super T>> Func1<T,java.lang.Boolean> greaterThan(@Nonnull
                                                                                                           T value)
```
    Create a function which returns true for submitted values greater than the given value.
    
    Type Parameters:
    
    T - a type which is comparable with itself
    
    Parameters:
    
    value - constant to compare against
    
    Returns:
    
    the function
  - greaterThan
```
@Nonnull
public static <T> Func1<T,java.lang.Boolean> greaterThan(@Nonnull
                                                                   T value,
                                                                   @Nonnull
                                                                   java.util.Comparator<? super T> comparator)
```
    Returns a function which returns true if the function parameter is greater than the constant in respect to the supplied comparator.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    value - constant to compare against
    
    comparator - the comparator for Ts.
    
    Returns:
    
    the function
  - identity
```
@Nonnull
public static <T> Func1<T,T> identity()
```
    Returns a function which returns its parameter value.
    
    Type Parameters:
    
    T - the type of the object
    
    Returns:
    
    the function which returns its parameter as is
  - identityFirst
```
@Nonnull
public static <T,U> Func2<T,U,T> identityFirst()
```
    Returns a helper function of two parameters which always returns its first parameter.
    
    Type Parameters:
    
    T - the result and the first parameter type
    
    U - the second parameter type, irrelevant
    
    Returns:
    
    the function
  - identitySecond
```
@Nonnull
public static <T,U> Func2<T,U,U> identitySecond()
```
    Returns a helper function of two parameters which always returns its second parameter.
    
    Type Parameters:
    
    T - the result and the second parameter type
    
    U - the first parameter type, irrelevant
    
    Returns:
    
    the function
  - incrementBigInteger
```
@Nonnull
public static Func1<java.math.BigInteger,java.math.BigInteger> incrementBigInteger()
```
    Returns:
    
    a function which returns param + 1 for BigIntegers.
  - incrementBy
```
@Nonnull
public static Func1<java.lang.Integer,java.lang.Integer> incrementBy(int value)
```
    Returns a function which increments its parameter by the given amount. Can be used to decrement if value is less than zero
    
    Parameters:
    
    value - the value to increment by
    
    Returns:
    
    the function
  - incrementBy
```
@Nonnull
public static Func1<java.lang.Long,java.lang.Long> incrementBy(long value)
```
    Returns a function which increments its parameter by the given amount. Can be used to decrement if value is less than zero
    
    Parameters:
    
    value - the value to increment by
    
    Returns:
    
    the function
  - incrementInt
```
@Nonnull
public static Func1<java.lang.Integer,java.lang.Integer> incrementInt()
```
    Returns:
    
    a function which returns param + 1 for Integers.
  - incrementLong
```
@Nonnull
public static Func1<java.lang.Long,java.lang.Long> incrementLong()
```
    Returns:
    
    a function which returns param + 1 for Longs.
  - lessOrEqual
```
@Nonnull
public static <T extends java.lang.Comparable<? super T>> Func1<T,java.lang.Boolean> lessOrEqual(@Nonnull
                                                                                                           T value)
```
    Create a function which returns true for submitted values less or equal than the given value.
    
    Type Parameters:
    
    T - a type which is comparable to itself
    
    Parameters:
    
    value - constant to compare against
    
    Returns:
    
    the function
  - lessOrEqual
```
@Nonnull
public static <T> Func1<T,java.lang.Boolean> lessOrEqual(@Nonnull
                                                                   T value,
                                                                   @Nonnull
                                                                   java.util.Comparator<? super T> comparator)
```
    Create a function which returns true for submitted values less or equal than the given value in respect to the supplied comparator.
    
    Type Parameters:
    
    T - a type which is comparable to itself
    
    Parameters:
    
    value - constant to compare against
    
    comparator - the comparator
    
    Returns:
    
    the function
  - lessThan
```
@Nonnull
public static <T extends java.lang.Comparable<? super T>> Func1<T,java.lang.Boolean> lessThan(@Nonnull
                                                                                                        T value)
```
    Create a function which returns true for submitted values less than the given value.
    
    Type Parameters:
    
    T - a type which is comparable with itself
    
    Parameters:
    
    value - constant to compare against
    
    Returns:
    
    the function
  - lessThan
```
@Nonnull
public static <T> Func1<T,java.lang.Boolean> lessThan(@Nonnull
                                                                T value,
                                                                @Nonnull
                                                                java.util.Comparator<? super T> comparator)
```
    Create a function which returns true for submitted values less than the given value in respect to the supplied comparator.
    
    Type Parameters:
    
    T - a type which is comparable to itself
    
    Parameters:
    
    value - constant to compare against
    
    comparator - the comparator
    
    Returns:
    
    the function
  - max
```
@Nonnull
public static <T extends java.lang.Comparable<? super T>> Func2<T,T,T> max()
```
    Returns a function which returns the greater of its parameters. If only one of the parameters is null, the other parameter is returned. If both parameters are null, null is returned.
    
    Type Parameters:
    
    T - the parameter types, which must be self-comparable
    
    Returns:
    
    the function
  - max
```
@Nonnull
public static <T> Func2<T,T,T> max(@Nonnull
                                             java.util.Comparator<? super T> comparator)
```
    Returns a function which returns the greater of its parameters in respect to the supplied Comparator. If only one of the parameters is null, the other parameter is returned. If both parameters are null, null is returned.
    
    Type Parameters:
    
    T - the parameter types, which must be self-comparable
    
    Parameters:
    
    comparator - the value comparator
    
    Returns:
    
    the function
  - min
```
@Nonnull
public static <T extends java.lang.Comparable<? super T>> Func2<T,T,T> min()
```
    Returns a function which returns the smaller of its parameters. If only one of the parameters is null, the other parameter is returned. If both parameters are null, null is returned.
    
    Type Parameters:
    
    T - the parameter types, which must be self-comparable
    
    Returns:
    
    the function
  - min
```
@Nonnull
public static <T> Func2<T,T,T> min(@Nonnull
                                             java.util.Comparator<? super T> comparator)
```
    Returns a function which returns the smaller of its parameters in respect to the supplied Comparator. If only one of the parameters is null, the other parameter is returned. If both parameters are null, null is returned.
    
    Type Parameters:
    
    T - the parameter types, which must be self-comparable
    
    Parameters:
    
    comparator - the value comparator
    
    Returns:
    
    the function
  - not
```
@Nonnull
public static Func0<java.lang.Boolean> not(@Nonnull
                                                     Func0<java.lang.Boolean> func)
```
    Creates a function which negates the supplied function's value.
    
    Parameters:
    
    func - the original function
    
    Returns:
    
    the wrapped negator function
  - notEqual
```
@Nonnull
public static <T> Func1<T,java.lang.Boolean> notEqual(@Nonnull
                                                                T value)
```
    Returns a function which returns true if its sumbitted parameter value does not equal to the given constant.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    value - the value
    
    Returns:
    
    the function
  - sumBigDecimal
```
@Nonnull
public static Func2<java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal> sumBigDecimal()
```
    Retuns a function that adds two BigDecimal numbers and returns a new one.
    If the first parameter is null, it returns the second parameter.
    
    Returns:
    
    Function to sum integers in aggregators.
  - sumBigInteger
```
@Nonnull
public static Func2<java.math.BigInteger,java.math.BigInteger,java.math.BigInteger> sumBigInteger()
```
    Retuns a function that adds two BigInteger numbers and returns a new one.
    If the first parameter is null, it returns the second parameter.
    
    Returns:
    
    Function to sum integers in aggregators.
  - sumDouble
```
@Nonnull
public static Func2<java.lang.Double,java.lang.Double,java.lang.Double> sumDouble()
```
    Retuns a function that adds two Double number and returns a new one.
    If the first parameter is null, it returns the second parameter.
    
    Returns:
    
    Function to sum integers in aggregators.
  - sumFloat
```
@Nonnull
public static Func2<java.lang.Float,java.lang.Float,java.lang.Float> sumFloat()
```
    Retuns a function that adds two Float number and returns a new one.
    If the first parameter is null, it returns the second parameter.
    
    Returns:
    
    Function to sum integers in aggregators.
  - sumInteger
```
@Nonnull
public static Func2<java.lang.Integer,java.lang.Integer,java.lang.Integer> sumInteger()
```
    Retuns a function that adds two Integer number and returns a new one.
    If the first parameter is null, it returns the second parameter.
    
    Returns:
    
    Function to sum integers in aggregators.
  - sumLong
```
@Nonnull
public static Func2<java.lang.Long,java.lang.Long,java.lang.Long> sumLong()
```
    Retuns a function that adds two Long number and returns a new one.
    If the first parameter is null, it returns the second parameter.
    
    Returns:
    
    Function to sum integers in aggregators.
  - equals
```
@Nonnull
public static <T> Func2<T,T,java.lang.Boolean> equals()
```
    Returns a function which compares its two parameters by a null-safe equals.
    
    Type Parameters:
    
    T - the parameter type
    
    Returns:
    
    the function
  - asFunc1
```
@Nonnull
public static <K,V> Func1<K,V> asFunc1(@Nonnull
                                                 java.util.Map<? super K,? extends V> map)
```
    Creates a single parameter function which returns values from the given map.
    
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Parameters:
    
    map - the backing map.
    
    Returns:
    
    the created function
    
    Since:
    
    0.96
  - asFunc2
```
@Nonnull
public static <K1,K2,V> Func2<K1,K2,V> asFunc2(@Nonnull
                                                         java.util.Map<? super K1,? extends java.util.Map<? super K2,? extends V>> map)
```
    Wraps a two-layer (map of map of something) into a two parameter function.
    If the first level map returns null, the function returns null.
    
    Type Parameters:
    
    K1 - the first level key type
    
    K2 - the second level key type
    
    V - the value type type
    
    Parameters:
    
    map - the source map of map of something
    
    Returns:
    
    the function
    
    Since:
    
    0.96
  - asFunc1
```
@Nonnull
public static <K> Func1<K,java.lang.Boolean> asFunc1(@Nonnull
                                                               java.util.Set<? super K> set)
```
    Creates a single parameter predicate function which returns true if the supplied parameter is in the given collection.
    
    Type Parameters:
    
    K - the element type
    
    Parameters:
    
    set - the backing set
    
    Returns:
    
    the created function
    
    Since:
    
    0.96
  - arrayListProvider
```
@Nonnull
public static <T> Func0<java.util.ArrayList<T>> arrayListProvider()
```
    A list creator factory.
    
    Type Parameters:
    
    T - the value type
    
    Returns:
    
    a function which creates a new empty instance of the given concrete list implementation.
    
    Since:
    
    0.96.1
  - arrayListProvider1
```
@Nonnull
public static <T,U> Func1<U,java.util.ArrayList<T>> arrayListProvider1()
```
    A list creator factory for Func1 that ignores the parameter.
    
    Type Parameters:
    
    T - the value type
    
    U - the function parameter type, ignored
    
    Returns:
    
    a function which creates a new empty instance of the given concrete list implementation.
    
    Since:
    
    0.97
  - linkedListProvider
```
@Nonnull
public static <T> Func0<java.util.LinkedList<T>> linkedListProvider()
```
    A list creator factory.
    
    Type Parameters:
    
    T - the value type
    
    Returns:
    
    a function which creates a new empty instance of the given concrete list implementation.
    
    Since:
    
    0.96.1
  - hashMapProvider
```
@Nonnull
public static <K,V> Func0<java.util.HashMap<K,V>> hashMapProvider()
```
    A map creator factory.
    
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Returns:
    
    a function which creates a new empty instance of the given concrete map implementation.
    
    Since:
    
    0.96.1
  - treeMapProvider
```
@Nonnull
public static <K,V> Func0<java.util.TreeMap<K,V>> treeMapProvider()
```
    A map creator factory.
    
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Returns:
    
    a function which creates a new empty instance of the given concrete map implementation.
    
    Since:
    
    0.96.1
  - treeMapProvider
```
@Nonnull
public static <K,V> Func0<java.util.TreeMap<K,V>> treeMapProvider(@Nonnull
                                                                            java.util.Comparator<? super K> keyComparator)
```
    A map creator factory.
    
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Parameters:
    
    keyComparator - the key comparator function
    
    Returns:
    
    a function which creates a new empty instance of the given concrete map implementation.
    
    Since:
    
    0.96.1
  - linkedHashMapProvider
```
@Nonnull
public static <K,V> Func0<java.util.LinkedHashMap<K,V>> linkedHashMapProvider()
```
    A map creator factory.
    
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Returns:
    
    a function which creates a new empty instance of the given concrete map implementation.
    
    Since:
    
    0.96.1
  - concurrentHashMapProvider
```
@Nonnull
public static <K,V> Func0<java.util.concurrent.ConcurrentHashMap<K,V>> concurrentHashMapProvider()
```
    A map creator factory.
    
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Returns:
    
    a function which creates a new empty instance of the given concrete map implementation.
    
    Since:
    
    0.96.1
  - hashSetProvider
```
@Nonnull
public static <T> Func0<java.util.HashSet<T>> hashSetProvider()
```
    A set creation provider.
    
    Type Parameters:
    
    T - the element type
    
    Returns:
    
    the function which creates an empty instance of the set
    
    Since:
    
    0.96.1
  - treeSetProvider
```
@Nonnull
public static <T> Func0<java.util.TreeSet<T>> treeSetProvider()
```
    A set creation provider.
    
    Type Parameters:
    
    T - the element type
    
    Returns:
    
    the function which creates an empty instance of the set
    
    Since:
    
    0.96.1
  - treeSetProvider
```
@Nonnull
public static <T> Func0<java.util.TreeSet<T>> treeSetProvider(@Nonnull
                                                                        java.util.Comparator<? super T> elementComparator)
```
    A set creation provider.
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    elementComparator - the custom element comparator
    
    Returns:
    
    the function which creates an empty instance of the set
    
    Since:
    
    0.96.1
  - asFunc2
```
@Nonnull
public static Func2<java.lang.Integer,java.lang.Integer,java.lang.Double> asFunc2(@Nonnull
                                                                                            double[][] values)
```
    Wrap the given two dimensional array into a function which returns the param1, param2 element.
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asFunc2
```
@Nonnull
public static Func2<java.lang.Integer,java.lang.Integer,java.lang.Integer> asFunc2(@Nonnull
                                                                                             int[][] values)
```
    Wrap the given two dimensional array into a function which returns the param1, param2 element.
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asFunc2
```
@Nonnull
public static Func2<java.lang.Integer,java.lang.Integer,java.lang.Long> asFunc2(@Nonnull
                                                                                          long[][] values)
```
    Wrap the given two dimensional array into a function which returns the param1, param2 element.
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asFunc2
```
@Nonnull
public static <T> Func2<java.lang.Integer,java.lang.Integer,T> asFunc2(@Nonnull
                                                                                 T[][] values)
```
    Wrap the given two dimensional array into a function which returns the param1, param2 element.
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asFunc1
```
@Nonnull
public static Func1<java.lang.Integer,java.lang.Double> asFunc1(@Nonnull
                                                                          double... values)
```
    Wrap the given one dimensional array into a function which returns the param1 element.
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asFunc1
```
@Nonnull
public static Func1<java.lang.Integer,java.lang.Long> asFunc1(@Nonnull
                                                                        long... values)
```
    Wrap the given one dimensional array into a function which returns the param1 element.
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asFunc1
```
@Nonnull
public static Func1<java.lang.Integer,java.lang.Integer> asFunc1(@Nonnull
                                                                           int... values)
```
    Wrap the given one dimensional array into a function which returns the param1 element.
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asFunc1
```
@Nonnull
public static <T> Func1<java.lang.Integer,T> asFunc1(@Nonnull
                                                               java.util.List<? extends T> values)
```
    Wrap the given list into a function which returns the param1 element.
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asDoubleFunc1
```
@Nonnull
public static Func1<java.lang.Integer,java.lang.Double> asDoubleFunc1(@Nonnull
                                                                                java.util.List<? extends java.lang.Number> values)
```
    Wrap the given list of number into a function which returns the param1 element as double.
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asIntFunc1
```
@Nonnull
public static Func1<java.lang.Integer,java.lang.Integer> asIntFunc1(@Nonnull
                                                                              java.util.List<? extends java.lang.Number> values)
```
    Wrap the given list of number into a function which returns the param1 element as int.
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asLongFunc1
```
@Nonnull
public static Func1<java.lang.Integer,java.lang.Long> asLongFunc1(@Nonnull
                                                                            java.util.List<? extends java.lang.Number> values)
```
    Wrap the given list of number into a function which returns the param1 element as long.
    
    Parameters:
    
    values - the values
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - and
```
@Nonnull
public static <T> Func1<T,java.lang.Boolean> and(@Nonnull
                                                           Func1<? super T,java.lang.Boolean> f1,
                                                           @Nonnull
                                                           Func1<? super T,java.lang.Boolean> f2)
```
    Returns a function which takes the logical AND of the given two functions when invoked.
    
    Type Parameters:
    
    T - the parameter type
    
    Parameters:
    
    f1 - the first function
    
    f2 - the second function
    
    Returns:
    
    the combined function
    
    Since:
    
    0.96.1
  - or
```
@Nonnull
public static Func2<java.lang.Boolean,java.lang.Boolean,java.lang.Boolean> or()
```
    Returns:
    
    curried logical OR
  - or
```
@Nonnull
public static <T> Func1<T,java.lang.Boolean> or(@Nonnull
                                                          Func1<? super T,java.lang.Boolean> f1,
                                                          @Nonnull
                                                          Func1<? super T,java.lang.Boolean> f2)
```
    Returns a function which takes the logical OR of the given two functions when invoked.
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    f1 - the first function
    
    f2 - the second function
    
    Returns:
    
    the combined function
    
    Since:
    
    0.96.1
  - xor
```
@Nonnull
public static <T> Func1<T,java.lang.Boolean> xor(@Nonnull
                                                           Func1<? super T,java.lang.Boolean> f1,
                                                           @Nonnull
                                                           Func1<? super T,java.lang.Boolean> f2)
```
    Returns a function which takes the logical XOR of the given two functions when invoked.
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    f1 - the first function
    
    f2 - the second function
    
    Returns:
    
    the combined function
    
    Since:
    
    0.96.1
  - and
```
@Nonnull
public static <T,U> Func2<T,U,java.lang.Boolean> and(@Nonnull
                                                               Func2<? super T,? super U,java.lang.Boolean> f1,
                                                               @Nonnull
                                                               Func2<? super T,? super U,java.lang.Boolean> f2)
```
    Returns a function which takes the logical AND of the given two functions when invoked.
    
    Type Parameters:
    
    T - the first parameter type
    
    U - the second parameter type
    
    Parameters:
    
    f1 - the first function
    
    f2 - the second function
    
    Returns:
    
    the combined function
    
    Since:
    
    0.96.1
  - or
```
@Nonnull
public static <T,U> Func2<T,U,java.lang.Boolean> or(@Nonnull
                                                              Func2<? super T,? super U,java.lang.Boolean> f1,
                                                              @Nonnull
                                                              Func2<? super T,? super U,java.lang.Boolean> f2)
```
    Returns a function which takes the logical OR of the given two functions when invoked.
    
    Type Parameters:
    
    T - the first parameter type
    
    U - the second parameter type
    
    Parameters:
    
    f1 - the first function
    
    f2 - the second function
    
    Returns:
    
    the combined function
    
    Since:
    
    0.96.1
  - xor
```
@Nonnull
public static <T,U> Func2<T,U,java.lang.Boolean> xor(@Nonnull
                                                               Func2<? super T,? super U,java.lang.Boolean> f1,
                                                               @Nonnull
                                                               Func2<? super T,? super U,java.lang.Boolean> f2)
```
    Returns a function which takes the logical XOR of the given two functions when invoked.
    
    Type Parameters:
    
    T - the first parameter type
    
    U - the second parameter type
    
    Parameters:
    
    f1 - the first function
    
    f2 - the second function
    
    Returns:
    
    the combined function
    
    Since:
    
    0.96.1
  - not
```
@Nonnull
public static <T> Func1<T,java.lang.Boolean> not(@Nonnull
                                                           Func1<? super T,java.lang.Boolean> f)
```
    Returns a function which creates the logical not of the wrapped function value for value t:T.
    
    Type Parameters:
    
    T - the parameter type
    
    Parameters:
    
    f - the function to wrap
    
    Returns:
    
    the new function
    
    Since:
    
    0.96.1
  - not
```
@Nonnull
public static <T,U> Func2<T,U,java.lang.Boolean> not(@Nonnull
                                                               Func2<? super T,? super U,java.lang.Boolean> f)
```
    Returns a function which creates the logical not of the wrapped function value for value t:T and u:U.
    
    Type Parameters:
    
    T - the first parameter type
    
    U - the second parameter type
    
    Parameters:
    
    f - the function to wrap
    
    Returns:
    
    the new function
    
    Since:
    
    0.96.1
  - asFunc0
```
@Nonnull
public static <T> Func0<T> asFunc0(@Nonnull
                                             java.lang.ref.Reference<? extends T> ref)
```
    Wrap the given reference into a function.
    Note that the references may return null if their contained object gets garbage collected.
    
    Type Parameters:
    
    T - the referenced object type
    
    Parameters:
    
    ref - the reference object
    
    Returns:
    
    the function
  - and
```
@Nonnull
public static Func2<java.lang.Boolean,java.lang.Boolean,java.lang.Boolean> and()
```
    Returns:
    
    curried logical AND
  - and
```
@Nonnull
public static Func0<java.lang.Boolean> and(@Nonnull
                                                     Func0<java.lang.Boolean> f1,
                                                     @Nonnull
                                                     Func0<java.lang.Boolean> f2)
```
    Returns a function which takes the logical AND of the given two functions when invoked.
    
    Parameters:
    
    f1 - the first function
    
    f2 - the second function
    
    Returns:
    
    the combined function
    
    Since:
    
    0.96.1
  - or
```
@Nonnull
public static Func0<java.lang.Boolean> or(@Nonnull
                                                    Func0<java.lang.Boolean> f1,
                                                    @Nonnull
                                                    Func0<java.lang.Boolean> f2)
```
    Returns a function which takes the logical OR of the given two functions when invoked.
    
    Parameters:
    
    f1 - the first function
    
    f2 - the second function
    
    Returns:
    
    the combined function
    
    Since:
    
    0.96.1
  - xor
```
@Nonnull
public static Func0<java.lang.Boolean> xor(@Nonnull
                                                     Func0<java.lang.Boolean> f1,
                                                     @Nonnull
                                                     Func0<java.lang.Boolean> f2)
```
    Returns a function which takes the logical XOR of the given two functions when invoked.
    
    Parameters:
    
    f1 - the first function
    
    f2 - the second function
    
    Returns:
    
    the combined function
    
    Since:
    
    0.96.1
  - asFunc1
```
@Nonnull
public static <T,U> Func1<T,U> asFunc1(@Nonnull
                                                 Func0<? extends U> f)
```
    Wraps the given zero parameter function into a 1 parameter function which ignores its parameter.
    
    Type Parameters:
    
    T - the function parameter type (irrelevant)
    
    U - the function return type
    
    Parameters:
    
    f - the function to wrap
    
    Returns:
    
    the new function
    
    Since:
    
    0.96.1
  - asFunc2
```
@Nonnull
public static <T,U,V> Func2<T,U,V> asFunc2(@Nonnull
                                                     Func0<? extends V> f)
```
    Wraps the given zero parameter function into a 2 parameter function which ignores its parameters.
    
    Type Parameters:
    
    T - the function first parameter type (irrelevant)
    
    U - the function second parameter type (irrelevant)
    
    V - the function return type
    
    Parameters:
    
    f - the function to wrap
    
    Returns:
    
    the new function
    
    Since:
    
    0.96.1
  - constant2
```
@Nonnull
public static <T,U,V> Func2<T,U,V> constant2(V value)
```
    Creates a constant function which always returns the given value regardless of the parameters.
    
    Type Parameters:
    
    T - the first parameter type, irrelevant
    
    U - the second parameter type, irrelevant
    
    V - the return type
    
    Parameters:
    
    value - the value to return
    
    Returns:
    
    the created function
  - asFunc0
```
@Nonnull
public static <T> Func0<T> asFunc0(java.lang.Runnable action,
                                             T result)
```
    Wraps the given Runnable into a function which calls the action and then returns the result value.
    
    Type Parameters:
    
    T - the result type
    
    Parameters:
    
    action - the action to invoke
    
    result - the result to present after the action invocation
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asFunc1
```
@Nonnull
public static <T,U> Func1<T,U> asFunc1(@Nonnull
                                                 java.lang.Runnable action,
                                                 U result)
```
    Wraps the given Runnable into a function which calls the action and then returns the result value.
    
    Type Parameters:
    
    T - the parameter type, irrelevant
    
    U - the result type
    
    Parameters:
    
    action - the action to invoke
    
    result - the result to present after the action invocation
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asFunc1
```
@Nonnull
public static <T,U> Func1<T,U> asFunc1(@Nonnull
                                                 Action0 action,
                                                 U result)
```
    Wraps the given action into a function which calls the action and then returns the result value.
    
    Type Parameters:
    
    T - the parameter type, irrelevant
    
    U - the result type
    
    Parameters:
    
    action - the action to invoke
    
    result - the result to present after the action invocation
    
    Returns:
    
    the function
    
    Since:
    
    0.96.1
  - asFunc1
```
@Nonnull
public static <T,U> Func1<T,U> asFunc1(@Nonnull
                                                 java.util.concurrent.Callable<? extends U> call)
```
    Wraps the given callable function into a 1 parameter function.
    If the callable throws an exception, it gets wrapped into RuntimeException and gets rethrown.
    
    Type Parameters:
    
    T - the function parameter type, irrelevant
    
    U - the return type
    
    Parameters:
    
    call - the callable instance
    
    Returns:
    
    the new function
  - asFunc2
```
public static <T,U,V> Func2<T,U,V> asFunc2(@Nonnull
                                           java.util.concurrent.Callable<? extends V> call)
```
    Wraps the given callable function into a 2 parameter function.
    If the callable throws an exception, it gets wrapped into RuntimeException and gets rethrown.
    
    Type Parameters:
    
    T - the function first parameter type, irrelevant
    
    U - the function second parameter type, irrelevant
    
    V - the return type
    
    Parameters:
    
    call - the callable instance
    
    Returns:
    
    the new function
  - asFunc2
```
@Nonnull
public static <T,U,V> Func2<T,U,V> asFunc2(@Nonnull
                                                     Action0 action,
                                                     V value)
```
    Wraps the given action into a 2 parameter function which returns the supplied value.
    If the callable throws an exception, it gets wrapped into RuntimeException and gets rethrown.
    
    Type Parameters:
    
    T - the function first parameter type, irrelevant
    
    U - the function second parameter type, irrelevant
    
    V - the return type
    
    Parameters:
    
    action - the action to invoke
    
    value - the value to return
    
    Returns:
    
    the new function
  - asFunc2
```
@Nonnull
public static <T,U,V> Func2<T,U,V> asFunc2(@Nonnull
                                                     java.lang.Runnable action,
                                                     V value)
```
    Wraps the given Runnable into a 2 parameter function which returns the supplied value.
    If the callable throws an exception, it gets wrapped into RuntimeException and gets rethrown.
    
    Type Parameters:
    
    T - the function first parameter type, irrelevant
    
    U - the function second parameter type, irrelevant
    
    V - the return type
    
    Parameters:
    
    action - the action to invoke
    
    value - the value to return
    
    Returns:
    
    the new function
  - pairUp
```
@Nonnull
public static <T,U> Func2<T,U,Pair<T,U>> pairUp()
```
    Type Parameters:
    
    T - the first parameter type
    
    U - the second parameter type
    
    Returns:
    
    a function which pairs its arguments
  - negate
```
@Nonnull
public static Func1<java.lang.Boolean,java.lang.Boolean> negate()
```
    Returns:
    
    Returns a function that negates the incoming boolean value.
  - swap
```
public static <T,U,V> Func2<T,U,V> swap(Func2<U,T,V> func)
```
    Returns a function which calls the supplied function with swapped parameter order.
    
    Type Parameters:
    
    T - the first parameter, becomes second in func
    
    U - the second parameter, becomes first in func
    
    V - the result type
    
    Parameters:
    
    func - the function to swap around.
    
    Returns:
    
    the swapping function.
    
    Since:
    
    0.97

Class Functions

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

FALSE

TRUE

EMPTY_RUNNABLE

INT_TO_LONG

LONG_TO_INT_CHECKED

LONG_TO_INT

Method Detail

alwaysFalse1

alwaysTrue1

alwaysFalse2

alwaysTrue2

asCallable

asComparator

asFunc0

asFunc1

asFunc2

asFunc0

asFunc2

asFunc0

asFunc0

asFunc0

asFunc0

comparator

comparator0

comparatorReverse

comparatorReverse

constant

constant0

decrementBigInteger

decrementInt

decrementLong

equal

greaterOrEqual

greaterOrEqual

greaterThan

greaterThan

identity

identityFirst

identitySecond

incrementBigInteger

incrementBy

incrementBy

incrementInt

incrementLong

lessOrEqual

lessOrEqual

lessThan

lessThan

max

max

min

min

not

notEqual

sumBigDecimal

sumBigInteger

sumDouble

sumFloat

sumInteger

sumLong

equals

asFunc1

asFunc2

asFunc1

arrayListProvider

arrayListProvider1

linkedListProvider

hashMapProvider

treeMapProvider

treeMapProvider

linkedHashMapProvider

concurrentHashMapProvider

hashSetProvider

treeSetProvider

treeSetProvider