Lang.F (Java Tool 1.20.2 API)

java.lang.Object
- java.lang.Enum<Lang.F>
- - org.osgl.Lang.F

All Implemented Interfaces:

Serializable, Comparable<Lang.F>

Enclosing class:

Lang
```
public static enum Lang.F
extends Enum<Lang.F>
```
The namespace to aggregate predefined core functions

Field Summary

Fields
Modifier and Type	Field and Description
`static Lang.F1`	`AS_STRING` A predefined function that when applied to an object instance, returns String representation of the instance
`static Lang.F2`	`EQ` A predefined function that applies to two parameters and check if they are equals to each other
`static Lang.F2`	`EQUAL` Alias of `EQ`
`static Lang.Predicate`	`FALSE` A predefined forever FALSE predicate which always return `false` for whatever element been tested
`static Lang.F2`	`GREATER_THAN` A function that apply to two parameters then return `true` if the first parameter is greater than the second one.
`static Lang.F2`	`GREATER_THAN_OR_EQUAL_TO` A function that apply to two parameters then return `true` if the first parameter is greater than or equal to the second one.
`static Lang.F1`	`HASH_CODE` A predefined function that calculate hash code of an object
`static Lang.F1`	`IDENTITY` A predefined function that when apply to a parameter it return it directly, so for any Object o
`static Lang.Predicate`	`IS_NULL` A predefined `Predicate` predicate test if the element specified is `null` or `Lang.NONE`.
`static Lang.F2`	`LESS_THAN` A function that apply to two parameters then return `true` if the first parameter is less than the second one.
`static Lang.F2`	`LESS_THAN_OR_EQUAL_TO` A function that apply to two parameters then return `true` if the first parameter is less than or equal to the second one.
`static Lang.Comparator`	`NATURAL_ORDER`
`static Lang.F2`	`NE` A predefined function that applies to two parameters and check if they are not equals to each other.
`static Lang.Predicate<Field>`	`NON_STATIC_FIELD` A predicate function that when applied to a `Field` type object, returns `true` when the field is not static
`static Lang.F2`	`NOT_EQUAL` Alias of `NE`
`static Lang.Predicate`	`NOT_NULL` A predefined `Predicate` predicate test if the element specified is NOT null
`static Lang.Comparator`	`REVERSE_ORDER`
`static Lang.Predicate`	`TRUE` A predefined forever true predicate which returns `true` on any element been tested

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> Lang.Predicate<T>`	`and(Collection<Lang.Function<? super T,Boolean>> predicates)` Returns a composed `Lang.Predicate` function that for any given parameter, the test result is `true` only when all of the specified predicates returns `true` when applied to the parameter
`static <T> Lang.Predicate<T>`	`and(Lang.Function<? super T,Boolean>... predicates)` Returns a composed `Lang.Predicate` function that for any given parameter, the test result is `true` only when all of the specified predicates returns `true` when applied to the parameter
`static <T> Lang.Predicate<T>`	`any(Collection<Lang.Function<? super T,Boolean>> predicates)` Alias of `or(Collection)`
`static <T> Lang.Predicate<T>`	`any(Lang.Function<? super T,Boolean>... predicates)` Alias of `#or(Function[])`
`static <T> Lang.F1<T,String>`	`asString()` A type-safe version of `AS_STRING`.
`static <T> Lang.F1<T,String>`	`asString(Class<T> tClass)` Type safe version of `AS_STRING`.
`static <T1,T2> Lang.F2<T1,T2,Void>`	`breakIf(Lang.Func2<? super T1,? super T2,Boolean> predicate)` Return a two variables function that throw out a `Lang.Break` when a two variables predicate return `true` on an element been tested.
`static <P,T1,T2> Lang.F2<T1,T2,Void>`	`breakIf(Lang.Func2<? super T1,? super T2,Boolean> predicate, P payload)` Return a two variables function that throw out a `Lang.Break` with payload specified when a two variables predicate return `true` on an element been tested
`static <T1,T2,T3> Lang.F3<T1,T2,T3,Void>`	`breakIf(Lang.Func3<? super T1,? super T2,? super T3,Boolean> predicate)` Return a three variables function that throw out a `Lang.Break` when a three variables predicate return `true` on an element been tested.
`static <P,T1,T2,T3> Lang.F3<T1,T2,T3,Void>`	`breakIf(Lang.Func3<? super T1,? super T2,? super T3,Boolean> predicate, P payload)` Return a three variables function that throw out a `Lang.Break` with payload specified when a three variables predicate return `true` on an element been tested
`static <T1,T2,T3,T4> Lang.F4<T1,T2,T3,T4,Void>`	`breakIf(Lang.Func4<? super T1,? super T2,? super T3,? super T4,Boolean> predicate)` Return a four variables function that throw out a `Lang.Break` when the predicate returns `true` on an element been tested.
`static <P,T1,T2,T3,T4> Lang.F4<T1,T2,T3,T4,Void>`	`breakIf(Lang.Func4<? super T1,? super T2,? super T3,? super T4,Boolean> predicate, P payload)` Return a four variables function that throw out a `Lang.Break` with payload specified when a four variables predicate return `true` on an element been tested
`static <T1,T2,T3,T4,T5> Lang.F5<T1,T2,T3,T4,T5,Void>`	`breakIf(Lang.Func5<? super T1,? super T2,? super T3,? super T4,? super T5,Boolean> predicate)` Return a five variables function that throw out a `Lang.Break` when the predicate returns `true` on an element been tested.
`static <P,T1,T2,T3,T4,T5> Lang.F5<T1,T2,T3,T4,T5,Void>`	`breakIf(Lang.Func5<? super T1,? super T2,? super T3,? super T4,? super T5,Boolean> predicate, P payload)` Return a five variables function that throw out a `Lang.Break` with payload specified when a five variables predicate return `true` on an element been tested
`static <T> Lang.F1<T,Void>`	`breakIf(Lang.Function<? super T,Boolean> predicate)` Return a one variable function that throw out a `Lang.Break` when a predicate return `true` on an element been tested.
`static <P,T> Lang.F1<T,Void>`	`breakIf(Lang.Function<? super T,Boolean> predicate, P payload)` Return a one variable function that throw out a `Lang.Break` with payload specified when a predicate return `true` on an element been tested
`static <T,U extends Comparable<? super U>> Lang.Comparator<T>`	`comparing(Lang.Function<? super T,? extends U> keyExtractor)`
`static <T,U> Lang.Comparator<T>`	`comparing(Lang.Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)` Construct a `Comparator` with a function to extract the key of type U from given object of type T and a comparator to compare type U
`static <P1,P2> Lang.F2<P1,P2,Boolean>`	`eq()` The type-safe version of `EQ`
`static <P> Lang.Predicate<P>`	`eq(P element)` Returns a `Lang.Predicate` that checkes if the argument equals to the element specified
`static <P1,P2> Lang.F2<P1,P2,Boolean>`	`equal()` Alias of `eq()`
`static Lang.Predicate<Field>`	`fieldWithAnnotation(Class<? extends Annotation> annoClass)` Returns a predicate function that when applied to a `Field` type object, returns `true` if the field has specified annotation presented
`static <T extends Comparable<T>> Lang.F2<T,T,Boolean>`	`greaterThan()` Alias of `gt()`
`static <T> Lang.F2<T,T,Boolean>`	`greaterThan(Comparator<? super T> c)` Alias of `gt(java.util.Comparator)`
`static <T> Lang.F2<T,T,Boolean>`	`greaterThan(Lang.Func2<? super T,? super T,Integer> c)` Alias of `gt(java.util.Comparator)`
`static <T extends Comparable<T>> Lang.F1<T,Boolean>`	`greaterThan(T v)` Alias of `gt(Comparable)`
`static <T extends Comparable<T>> Lang.F2<T,T,Boolean>`	`greaterThanOrEqualsTo()` Alias of `gte()`
`static <T> Lang.F2<T,T,Boolean>`	`greaterThanOrEqualsTo(Comparator<? super T> c)` Alias of `gte(java.util.Comparator)`
`static <T> Lang.F2<T,T,Boolean>`	`greaterThanOrEqualsTo(Lang.Func2<? super T,? super T,Integer> c)` Alias of `gte(java.util.Comparator)`
`static <T extends Comparable<T>> Lang.F1<T,Boolean>`	`greaterThanOrEqualsTo(T v)` Alias of `gte(Comparable)`
`static <T extends Comparable<T>> Lang.F2<T,T,Boolean>`	`gt()` Returns a function that check if a value is less than another one.
`static <T> Lang.F2<T,T,Boolean>`	`gt(Comparator<? super T> c)` Returns a function that check if a value is less than another one using the `Comparator` specified
`static <T> Lang.F2<T,T,Boolean>`	`gt(Lang.Func2<? super T,? super T,Integer> c)` Returns a function that check if a value is less than another one using the `Comparator` specified
`static <T extends Comparable<T>> Lang.F1<T,Boolean>`	`gt(T v)` Returns a function that apply to one parameter and compare it with the value `v` specified, returns `true` if the parameter applied is greater than `v`
`static <T extends Comparable<T>> Lang.F2<T,T,Boolean>`	`gte()` Returns a function that check if a value is greater than or equals to another one.
`static <T> Lang.F2<T,T,Boolean>`	`gte(Comparator<? super T> c)` Returns a function that check if a value is greater than or equals to another one using the `Comparator` specified
`static <T> Lang.F2<T,T,Boolean>`	`gte(Lang.Func2<? super T,? super T,Integer> c)` Returns a function that check if a value is greater than or equals to another one using the `Comparator` specified
`static <T extends Comparable<T>> Lang.F1<T,Boolean>`	`gte(T v)` Returns a function that apply to one parameter and compare it with the value `v` specified, returns `true` if the parameter applied is greater than or equals to `v`
`static <T> Lang.F1<T,Integer>`	`hc()` The type-safe version of `HASH_CODE`
`static <T> Lang.F1<T,T>`	`identity()` The type-safe version of `IDENTITY`
`static <T> Lang.F1<T,T>`	`identity(Class<T> clz)` The type-safe version of `IDENTITY`
`static <X,Y> Lang.Bijection<Y,X>`	`invert(Lang.Bijection<X,Y> f)` Returns a inverted function of `Lang.Bijection` which map from X to Y, and the returned function map from Y to X.
`static <T> Lang.Predicate<T>`	`isNull()` The type-safe version of `IS_NULL`
`static <T> Lang.Predicate<T>`	`isNull(Class<T> c)` The type-safe version of `IS_NULL`
`static <T extends Comparable<T>> Lang.F2<T,T,Boolean>`	`lessThan()` Alias of `lt()`
`static <T> Lang.F2<T,T,Boolean>`	`lessThan(Comparator<? super T> c)` Alias of `lt(java.util.Comparator)`
`static <T> Lang.F2<T,T,Boolean>`	`lessThan(Lang.Func2<? super T,? super T,Integer> c)` Alias of `lt(java.util.Comparator)`
`static <T extends Comparable<T>> Lang.F1<T,Boolean>`	`lessThan(T v)` Alias of `lt(Comparable)`
`static <T extends Comparable<T>> Lang.F2<T,T,Boolean>`	`lessThanOrEqualsTo()` Alias of `lte()`
`static <T> Lang.F2<T,T,Boolean>`	`lessThanOrEqualsTo(Comparator<? super T> c)` Alias of `lte(java.util.Comparator)`
`static <T> Lang.F2<T,T,Boolean>`	`lessThanOrEqualsTo(Lang.Func2<? super T,? super T,Integer> c)` Alias of `lte(java.util.Comparator)`
`static <T extends Comparable<T>> Lang.F1<T,Boolean>`	`lessThanOrEqualsTo(T v)` Alias of `lte(Comparable)`
`static <T extends Comparable<T>> Lang.F2<T,T,Boolean>`	`lt()` Returns a function that check if a value is less than another one.
`static <T> Lang.F2<T,T,Boolean>`	`lt(Comparator<? super T> c)` Returns a function that check if a value is less than another one using the `Comparator` specified
`static <T> Lang.F2<T,T,Boolean>`	`lt(Lang.Func2<? super T,? super T,Integer> c)` Returns a function that check if a value is less than another one using the `Comparator` specified
`static <T extends Comparable<T>> Lang.F1<T,Boolean>`	`lt(T v)` Returns a function that apply to one parameter and compare it with the value `v` specified, returns `true` if the parameter applied is less than `v`
`static <T extends Comparable<T>> Lang.F2<T,T,Boolean>`	`lte()` Returns a function that check if a value is less than or equals to another one.
`static <T> Lang.F2<T,T,Boolean>`	`lte(Comparator<? super T> c)` Returns a function that check if a value is less than or equals to another one using the `Comparator` specified
`static <T> Lang.F2<T,T,Boolean>`	`lte(Lang.Func2<? super T,? super T,Integer> c)` Returns a function that check if a value is less than or equals to another one using the `Comparator` specified
`static <T extends Comparable<T>> Lang.F1<T,Boolean>`	`lte(T v)` Returns a function that apply to one parameter and compare it with the value `v` specified, returns `true` if the parameter applied is less than or equals to `v`
`static <T extends Comparable<T>> Lang.Comparator<T>`	`naturalOrder()`
`static <P1,P2> Lang.F2<P1,P2,Boolean>`	`ne()` The type-safe version of `NE`
`static Lang.F0<Boolean>`	`negate(Lang.Func0<Boolean> predicate)` Returns a negate function of the specified predicate function
`static <P1,P2> Lang.F2<P1,P2,Boolean>`	`negate(Lang.Func2<? super P1,? super P2,Boolean> predicate)` Returns a negate function of the specified predicate that applied to 2 parameters and returns boolean value
`static <P1,P2,P3> Lang.F3<P1,P2,P3,Boolean>`	`negate(Lang.Func3<? super P1,? super P2,? super P3,Boolean> predicate)` Returns a negate function of the specified predicate that applied to 3 parameters and returns boolean value
`static <P1,P2,P3,P4> Lang.F4<P1,P2,P3,P4,Boolean>`	`negate(Lang.Func4<? super P1,? super P2,? super P3,? super P4,Boolean> predicate)` Returns a negate function of the specified predicate that applied to 3 parameters and returns boolean value
`static <P1,P2,P3,P4,P5> Lang.F5<P1,P2,P3,P4,P5,Boolean>`	`negate(Lang.Func5<? super P1,? super P2,? super P3,? super P4,? super P5,Boolean> predicate)` Returns a negate function of the specified predicate that applied to 3 parameters and returns boolean value
`static <T> Lang.Predicate<T>`	`negate(Lang.Function<? super T,Boolean> predicate)` Returns a negate function of the specified predicate function that applied to 1 params and returns boolean value
`static <T> Lang.Predicate<T>`	`no()` A type-safe version of `FALSE`
`static <T> Lang.Predicate<T>`	`none(Collection<Lang.Function<? super T,Boolean>> predicates)` Negation of `or(Collection)`
`static <T> Lang.Predicate<T>`	`none(Lang.Function<? super T,Boolean>... predicates)` Negation of `#or(Function[])`
`static <T> Lang.F1<T,Boolean>`	`not()` Returns a function that evaluate an argument’s boolean value and negate the value.
`static <P1,P2> Lang.F2<P1,P2,Boolean>`	`notEqual()` Alias of `ne()`
`static <T> Lang.Predicate<T>`	`or(Collection<Lang.Function<? super T,Boolean>> predicates)` Returns a composed `Lang.Predicate` function that for any given parameter, the test result is `true` only when any one of the specified predicates returns `true` when applied to the parameter
`static <T> Lang.Predicate<T>`	`or(Lang.Function<? super T,Boolean>... predicates)` Returns a composed `Lang.Predicate` function that for any given parameter, the test result is `true` when any one of the specified predicates returns `true` on the parameter
`static <BEAN> Lang.Transformer<BEAN,Object>`	`propertyExtractor(String property)`
`static <T> Lang.Val<T>`	`provides(T obj)` Return a provider that when called will return the object specified
`static <T> Lang.Predicate<T>`	`requireNotNull()` The type-safe version of `NOT_NULL`
`static <T> Lang.Comparator<T>`	`reverse(Comparator<? super T> c)`
`static <T extends Comparable<? super T>> Lang.Comparator<T>`	`reverseOrder()`
`static Lang.F`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static Lang.F[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.
`static <T> Lang.Predicate<T>`	`yes()` A type-safe version of `TRUE`

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - TRUE
```
public static final Lang.Predicate TRUE
```
    A predefined forever true predicate which returns true on any element been tested
    
    Since:
    
    0.2
    
    See Also:
    
    yes()
  - FALSE
```
public static final Lang.Predicate FALSE
```
    A predefined forever FALSE predicate which always return false for whatever element been tested
    
    Since:
    
    0.2
    
    See Also:
    
    no()
  - IS_NULL
```
public static final Lang.Predicate IS_NULL
```
    A predefined Predicate predicate test if the element specified is null or Lang.NONE.
    
    Since:
    
    0.2
  - NOT_NULL
```
public static final Lang.Predicate NOT_NULL
```
    A predefined Predicate predicate test if the element specified is NOT null
    
    Since:
    
    0.2
  - IDENTITY
```
public static final Lang.F1 IDENTITY
```
    A predefined function that when apply to a parameter it return it directly, so for any Object o
```
  IDENTITY.apply(o) == o; 
```
    Since:
    
    0.2
  - LESS_THAN
```
public static final Lang.F2 LESS_THAN
```
    A function that apply to two parameters then return true if the first parameter is less than the second one. The type of the two parameter should be the same and should implements Comparable
    
    Since:
    
    0.2
  - GREATER_THAN
```
public static final Lang.F2 GREATER_THAN
```
    A function that apply to two parameters then return true if the first parameter is greater than the second one. The type of the two parameter should be the same and should implements Comparable
    
    Since:
    
    0.2
  - LESS_THAN_OR_EQUAL_TO
```
public static final Lang.F2 LESS_THAN_OR_EQUAL_TO
```
    A function that apply to two parameters then return true if the first parameter is less than or equal to the second one. The type of the two parameter should be the same and should implements Comparable
    
    Since:
    
    0.2
  - GREATER_THAN_OR_EQUAL_TO
```
public static final Lang.F2 GREATER_THAN_OR_EQUAL_TO
```
    A function that apply to two parameters then return true if the first parameter is greater than or equal to the second one. The type of the two parameter should be the same and should implements Comparable
    
    Since:
    
    0.2
  - EQ
```
public static final Lang.F2 EQ
```
    A predefined function that applies to two parameters and check if they are equals to each other
  - EQUAL
```
public static final Lang.F2 EQUAL
```
    Alias of EQ
    
    Since:
    
    0.2
  - NE
```
public static final Lang.F2 NE
```
    A predefined function that applies to two parameters and check if they are not equals to each other. This is a negate function of EQ
    
    Since:
    
    0.2
  - NOT_EQUAL
```
public static final Lang.F2 NOT_EQUAL
```
    Alias of NE
    
    Since:
    
    0.2
  - NATURAL_ORDER
```
public static final Lang.Comparator NATURAL_ORDER
```
  - REVERSE_ORDER
```
public static final Lang.Comparator REVERSE_ORDER
```
  - HASH_CODE
```
public static final Lang.F1 HASH_CODE
```
    A predefined function that calculate hash code of an object
    
    Since:
    
    0.2
    
    See Also:
    
    Lang.hc(Object)
  - AS_STRING
```
public static final Lang.F1 AS_STRING
```
    A predefined function that when applied to an object instance, returns String representation of the instance
    
    Since:
    
    0.2
    
    See Also:
    
    Lang.toString2(Object)
  - NON_STATIC_FIELD
```
public static Lang.Predicate<Field> NON_STATIC_FIELD
```
    A predicate function that when applied to a Field type object, returns true when the field is not static
- Method Detail
  - values
```
public static Lang.F[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (Lang.F c : Lang.F.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static Lang.F valueOf(String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    
    name - the name of the enum constant to be returned.
    
    Returns:
    
    the enum constant with the specified name
    
    Throws:
    
    IllegalArgumentException - if this enum type has no constant with the specified name
    
    NullPointerException - if the argument is null
  - breakIf
```
public static <P,T> Lang.F1<T,Void> breakIf(Lang.Function<? super T,Boolean> predicate,
                                            P payload)
```
    Return a one variable function that throw out a Lang.Break with payload specified when a predicate return true on an element been tested
    
    Type Parameters:
    
    P - the type of the payload object
    
    T - the type of the object to be consumed by the predicate
    
    Parameters:
    
    predicate - the predicate function that takes T type argument
    
    payload - the payload to be passed into the Lang.Break if predicate returns true
    
    Returns:
    
    an new function that takes T argument and apply it to the predicate. If the result is true then throw out the Break with payload specified
    
    Since:
    
    0.2
  - breakIf
```
public static <T> Lang.F1<T,Void> breakIf(Lang.Function<? super T,Boolean> predicate)
```
    Return a one variable function that throw out a Lang.Break when a predicate return true on an element been tested. There is no payload specified and the Break will use test result i.e. true as the payload
    
    Type Parameters:
    
    T - the type of the object consumed by the predicate
    
    Parameters:
    
    predicate - the predicate function
    
    Returns:
    
    a new function that applies the predicate and if the result is true then throw out a Lang.Break with payload of the object been consumed
    
    Since:
    
    0.2
  - breakIf
```
public static <P,T1,T2> Lang.F2<T1,T2,Void> breakIf(Lang.Func2<? super T1,? super T2,Boolean> predicate,
                                                    P payload)
```
    Return a two variables function that throw out a Lang.Break with payload specified when a two variables predicate return true on an element been tested
    
    Type Parameters:
    
    P - the payload type
    
    T1 - the type of the first argument
    
    T2 - the type of the second argument
    
    Parameters:
    
    predicate - the function test the arguments
    
    payload - the payload to be thrown out if predicate function returns true on the argument
    
    Returns:
    
    a function that apply predicate to arguments and throw Lang.Break with payload specified
    
    Since:
    
    0.2
  - breakIf
```
public static <T1,T2> Lang.F2<T1,T2,Void> breakIf(Lang.Func2<? super T1,? super T2,Boolean> predicate)
```
    Return a two variables function that throw out a Lang.Break when a two variables predicate return true on an element been tested. There is no payload specified and the Break will use test result i.e. true as the payload
    
    Type Parameters:
    
    T1 - the type of argument 1
    
    T2 - the type of argument 2
    
    Parameters:
    
    predicate - the predicate function check if a break should be raised
    
    Returns:
    
    the function that raise Lang.Break if predicate function says true on the two arguments
    
    Since:
    
    0.2
  - breakIf
```
public static <P,T1,T2,T3> Lang.F3<T1,T2,T3,Void> breakIf(Lang.Func3<? super T1,? super T2,? super T3,Boolean> predicate,
                                                          P payload)
```
    Return a three variables function that throw out a Lang.Break with payload specified when a three variables predicate return true on an element been tested
    
    Type Parameters:
    
    P - Generic type for payload
    
    T1 - generic type of the first argument taken by predicate
    
    T2 - generic type of the second argument taken by predicate
    
    T3 - generic type of the thrid argument taken by predicate
    
    Parameters:
    
    predicate - the predicate function that takes three arguments and returns a boolean type value
    
    payload - the payload object to be
    
    Returns:
    
    A function of F3<T1, T2, T3, Void> type
    
    Since:
    
    0.2
  - breakIf
```
public static <T1,T2,T3> Lang.F3<T1,T2,T3,Void> breakIf(Lang.Func3<? super T1,? super T2,? super T3,Boolean> predicate)
```
    Return a three variables function that throw out a Lang.Break when a three variables predicate return true on an element been tested. There is no payload specified and the Break will use test result i.e. true as the payload
    
    Type Parameters:
    
    T1 - the generic type of the argument 1
    
    T2 - the generic type of the argument 2
    
    T3 - the generic type of the argument 3
    
    Parameters:
    
    predicate - the predicate function that takes three arguments and returns a boolean type value
    
    Returns:
    
    a function that check on three arguments and throw out true if the check returns true
    
    Since:
    
    0.2
  - breakIf
```
public static <P,T1,T2,T3,T4> Lang.F4<T1,T2,T3,T4,Void> breakIf(Lang.Func4<? super T1,? super T2,? super T3,? super T4,Boolean> predicate,
                                                                P payload)
```
    Return a four variables function that throw out a Lang.Break with payload specified when a four variables predicate return true on an element been tested
    
    Type Parameters:
    
    P - the generic type of the payload
    
    T1 - the generic type of the argument 1
    
    T2 - the generic type of the argument 2
    
    T3 - the generic type of the argument 3
    
    T4 - the generic type of the argument 4
    
    Parameters:
    
    predicate - the predicate function that takes four arguments and returns a boolean type value
    
    payload - the payload to be throw out if the predicate function returns true on given arguments
    
    Returns:
    
    a function that check on four arguments and throw out payload if the check returns true
    
    Since:
    
    0.2
  - breakIf
```
public static <T1,T2,T3,T4> Lang.F4<T1,T2,T3,T4,Void> breakIf(Lang.Func4<? super T1,? super T2,? super T3,? super T4,Boolean> predicate)
```
    Return a four variables function that throw out a Lang.Break when the predicate returns true on an element been tested. There is no payload specified and the Break will use test result i.e. true as the payload
    
    Type Parameters:
    
    T1 - the generic type of the argument 1
    
    T2 - the generic type of the argument 2
    
    T3 - the generic type of the argument 3
    
    T4 - the generic type of the argument 4
    
    Parameters:
    
    predicate - the predicate function that takes four arguments and returns a boolean type value
    
    Returns:
    
    a function that check on four arguments and throw out true if the check returns true
    
    Since:
    
    0.2
  - breakIf
```
public static <P,T1,T2,T3,T4,T5> Lang.F5<T1,T2,T3,T4,T5,Void> breakIf(Lang.Func5<? super T1,? super T2,? super T3,? super T4,? super T5,Boolean> predicate,
                                                                      P payload)
```
    Return a five variables function that throw out a Lang.Break with payload specified when a five variables predicate return true on an element been tested
    
    Type Parameters:
    
    P - the generic type of the payload
    
    T1 - the generic type of the argument 1
    
    T2 - the generic type of the argument 2
    
    T3 - the generic type of the argument 3
    
    T4 - the generic type of the argument 4
    
    T5 - the generic type of the argument 5
    
    Parameters:
    
    predicate - the predicate function that takes five arguments and returns a boolean type value
    
    payload - the payload to be throw out if the predicate function returns true on given arguments
    
    Returns:
    
    a function that check on five arguments and throw out payload if the check returns true
    
    Since:
    
    0.2
  - breakIf
```
public static <T1,T2,T3,T4,T5> Lang.F5<T1,T2,T3,T4,T5,Void> breakIf(Lang.Func5<? super T1,? super T2,? super T3,? super T4,? super T5,Boolean> predicate)
```
    Return a five variables function that throw out a Lang.Break when the predicate returns true on an element been tested. There is no payload specified and the Break will use test result i.e. true as the payload
    
    Type Parameters:
    
    T1 - the generic type of the argument 1
    
    T2 - the generic type of the argument 2
    
    T3 - the generic type of the argument 3
    
    T4 - the generic type of the argument 4
    
    T5 - the generic type of the argument 5
    
    Parameters:
    
    predicate - the predicate function that takes five arguments and returns a boolean type value
    
    Returns:
    
    a function that check on five arguments and throw out true if the check returns true
    
    Since:
    
    0.2
  - and
```
public static <T> Lang.Predicate<T> and(Collection<Lang.Function<? super T,Boolean>> predicates)
```
    Returns a composed Lang.Predicate function that for any given parameter, the test result is true only when all of the specified predicates returns true when applied to the parameter
    
    Type Parameters:
    
    T - the type of the parameter the predicates applied to
    
    Parameters:
    
    predicates - a collection of predicates that can be applied to a parameter and returns boolean value
    
    Returns:
    
    a composed function
    
    Since:
    
    0.2
  - and
```
public static <T> Lang.Predicate<T> and(Lang.Function<? super T,Boolean>... predicates)
```
    Returns a composed Lang.Predicate function that for any given parameter, the test result is true only when all of the specified predicates returns true when applied to the parameter
    
    Type Parameters:
    
    T - the type of the parameter the predicates applied to
    
    Parameters:
    
    predicates - an array of predicates that can be applied to a parameter and returns boolean value
    
    Returns:
    
    a composed function
    
    Since:
    
    0.2
  - or
```
public static <T> Lang.Predicate<T> or(Collection<Lang.Function<? super T,Boolean>> predicates)
```
    Returns a composed Lang.Predicate function that for any given parameter, the test result is true only when any one of the specified predicates returns true when applied to the parameter
    
    Type Parameters:
    
    T - the type of the parameter the predicates applied to
    
    Parameters:
    
    predicates - a collection of predicates that can be applied to a parameter and returns boolean value
    
    Returns:
    
    a composed function
    
    Since:
    
    0.2
  - or
```
public static <T> Lang.Predicate<T> or(Lang.Function<? super T,Boolean>... predicates)
```
    Returns a composed Lang.Predicate function that for any given parameter, the test result is true when any one of the specified predicates returns true on the parameter
    
    Type Parameters:
    
    T - the type of the parameter the predicates applied to
    
    Parameters:
    
    predicates - an array of predicates that can be applied to a parameter and returns boolean value
    
    Returns:
    
    a composed function
    
    Since:
    
    0.2
  - any
```
public static <T> Lang.Predicate<T> any(Collection<Lang.Function<? super T,Boolean>> predicates)
```
    Alias of or(Collection)
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    predicates - the predicate functions
    
    Returns:
    
    a function that returns true if any one of the predicates returns true on a given argument
    
    Since:
    
    0.2
  - any
```
public static <T> Lang.Predicate<T> any(Lang.Function<? super T,Boolean>... predicates)
```
    Alias of #or(Function[])
    
    Type Parameters:
    
    T - the argument type
    
    Parameters:
    
    predicates - an array of predicate functions
    
    Returns:
    
    the function that returns true if any one of the predicate function returns true
    
    Since:
    
    0.2
  - none
```
public static <T> Lang.Predicate<T> none(Collection<Lang.Function<? super T,Boolean>> predicates)
```
    Negation of or(Collection)
    
    Type Parameters:
    
    T - the generic type of the argument the predicate functions take
    
    Parameters:
    
    predicates - an iterable of predicate functions
    
    Returns:
    
    a function that apply the argument to all predicate functions and return true if all of them return false on the argument, or false if any one of them returns true
    
    Since:
    
    0.2
  - none
```
public static <T> Lang.Predicate<T> none(Lang.Function<? super T,Boolean>... predicates)
```
    Negation of #or(Function[])
    
    Type Parameters:
    
    T - the generic type of the argument the predicate functions take
    
    Parameters:
    
    predicates - an array of predicate functions
    
    Returns:
    
    a function that apply the argument to all predicate functions and return true if all of them return false on the argument, or false if any one of them returns true
    
    Since:
    
    0.2
  - not
```
public static <T> Lang.F1<T,Boolean> not()
```
    Returns a function that evaluate an argument’s boolean value and negate the value.
    
    Type Parameters:
    
    T - the type of the argument the function applied to
    
    Returns:
    
    the function returns true if an argument evaluated to false, or vice versa
  - invert
```
public static <X,Y> Lang.Bijection<Y,X> invert(Lang.Bijection<X,Y> f)
```
    Returns a inverted function of Lang.Bijection which map from X to Y, and the returned function map from Y to X. This function will call Lang.Bijection.invert() to get the return function
    
    Type Parameters:
    
    X - the argument type, and the result type of the return function
    
    Y - the result type, and the argument type of the return function
    
    Parameters:
    
    f - the bijection function to be inverted
    
    Returns:
    
    the inverted function of input function f
  - negate
```
public static Lang.F0<Boolean> negate(Lang.Func0<Boolean> predicate)
```
    Returns a negate function of the specified predicate function
    
    Parameters:
    
    predicate - the specified function that returns boolean value
    
    Returns:
    
    the function that negate the specified predicate
  - negate
```
public static <T> Lang.Predicate<T> negate(Lang.Function<? super T,Boolean> predicate)
```
    Returns a negate function of the specified predicate function that applied to 1 params and returns boolean value
    
    Type Parameters:
    
    T - the type of the parameter to be applied
    
    Parameters:
    
    predicate - the specified function that applied to the parameter and returns boolean value
    
    Returns:
    
    the function that negate the specified predicate
  - negate
```
public static <P1,P2> Lang.F2<P1,P2,Boolean> negate(Lang.Func2<? super P1,? super P2,Boolean> predicate)
```
    Returns a negate function of the specified predicate that applied to 2 parameters and returns boolean value
    
    Type Parameters:
    
    P1 - type of param one
    
    P2 - type of param two
    
    Parameters:
    
    predicate - the function applied to 2 params and return boolean value
    
    Returns:
    
    the function that negate predicate specified
  - negate
```
public static <P1,P2,P3> Lang.F3<P1,P2,P3,Boolean> negate(Lang.Func3<? super P1,? super P2,? super P3,Boolean> predicate)
```
    Returns a negate function of the specified predicate that applied to 3 parameters and returns boolean value
    
    Type Parameters:
    
    P1 - type of param one
    
    P2 - type of param two
    
    P3 - type of param three
    
    Parameters:
    
    predicate - the function applied to 2 params and return boolean value
    
    Returns:
    
    the function that negate predicate specified
  - negate
```
public static <P1,P2,P3,P4> Lang.F4<P1,P2,P3,P4,Boolean> negate(Lang.Func4<? super P1,? super P2,? super P3,? super P4,Boolean> predicate)
```
    Returns a negate function of the specified predicate that applied to 3 parameters and returns boolean value
    
    Type Parameters:
    
    P1 - type of param one
    
    P2 - type of param two
    
    P3 - type of param three
    
    P4 - type of param four
    
    Parameters:
    
    predicate - the function applied to 2 params and return boolean value
    
    Returns:
    
    the function that negate predicate specified
  - negate
```
public static <P1,P2,P3,P4,P5> Lang.F5<P1,P2,P3,P4,P5,Boolean> negate(Lang.Func5<? super P1,? super P2,? super P3,? super P4,? super P5,Boolean> predicate)
```
    Returns a negate function of the specified predicate that applied to 3 parameters and returns boolean value
    
    Type Parameters:
    
    P1 - type of param one
    
    P2 - type of param two
    
    P3 - type of param three
    
    P4 - type of param four
    
    P5 - type of param five
    
    Parameters:
    
    predicate - the function applied to 2 params and return boolean value
    
    Returns:
    
    the function that negate predicate specified
  - provides
```
public static <T> Lang.Val<T> provides(T obj)
```
    Return a provider that when called will return the object specified
    
    Type Parameters:
    
    T - the object type
    
    Parameters:
    
    obj - the object to be returned when calling the returning function
    
    Returns:
    
    a provider function that returns the object specified
  - yes
```
public static <T> Lang.Predicate<T> yes()
```
    A type-safe version of TRUE
    
    Type Parameters:
    
    T - the argument type
    
    Returns:
    
    a function that always returns true
    
    Since:
    
    0.2
  - no
```
public static <T> Lang.Predicate<T> no()
```
    A type-safe version of FALSE
    
    Type Parameters:
    
    T - the argument type
    
    Returns:
    
    a function that always return false
    
    Since:
    
    0.2
  - isNull
```
public static <T> Lang.Predicate<T> isNull()
```
    The type-safe version of IS_NULL
    
    Type Parameters:
    
    T - the argument type
    
    Returns:
    
    a function that check if an argument is null or NONE
    
    Since:
    
    0.2
  - isNull
```
public static <T> Lang.Predicate<T> isNull(Class<T> c)
```
    The type-safe version of IS_NULL
    
    Type Parameters:
    
    T - the argument type
    
    Parameters:
    
    c - the class that specifies the argument type
    
    Returns:
    
    a function that check if the argument is null or NONE
    
    Since:
    
    0.2
  - requireNotNull
```
public static <T> Lang.Predicate<T> requireNotNull()
```
    The type-safe version of NOT_NULL
    
    Type Parameters:
    
    T - the element type
    
    Returns:
    
    a function that check if argument is null or NONE
    
    Since:
    
    0.2
  - identity
```
public static <T> Lang.F1<T,T> identity()
```
    The type-safe version of IDENTITY
    
    Type Parameters:
    
    T - the element type
    
    Returns:
    
    the identity function that always return the argument itself
    
    Since:
    
    0.2
  - identity
```
public static <T> Lang.F1<T,T> identity(Class<T> clz)
```
    The type-safe version of IDENTITY
    
    Type Parameters:
    
    T - the generic type
    
    Parameters:
    
    clz - the class that restrict the type of <T>
    
    Returns:
    
    the identity function that when get called, always return the parameter
    
    Since:
    
    0.9
  - lt
```
public static <T extends Comparable<T>> Lang.F1<T,Boolean> lt(T v)
```
    Returns a function that apply to one parameter and compare it with the value v specified, returns true if the parameter applied is less than v
    
    Type Parameters:
    
    T - the type of the value and parameter
    
    Parameters:
    
    v - the value to be compare with the function parameter
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - lessThan
```
public static <T extends Comparable<T>> Lang.F1<T,Boolean> lessThan(T v)
```
    Alias of lt(Comparable)
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    v - a value used to check against function argument
    
    Returns:
    
    a function that check if a object is lesser than the value specified
    
    Since:
    
    0.2
  - gt
```
public static <T extends Comparable<T>> Lang.F1<T,Boolean> gt(T v)
```
    Returns a function that apply to one parameter and compare it with the value v specified, returns true if the parameter applied is greater than v
    
    Type Parameters:
    
    T - the type of the value and parameter
    
    Parameters:
    
    v - the value to be compare with the function parameter
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - greaterThan
```
public static <T extends Comparable<T>> Lang.F1<T,Boolean> greaterThan(T v)
```
    Alias of gt(Comparable)
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    v - the value used to check against function argument
    
    Returns:
    
    a function that check if a object is greater than the value specified
    
    Since:
    
    0.2
  - gte
```
public static <T extends Comparable<T>> Lang.F1<T,Boolean> gte(T v)
```
    Returns a function that apply to one parameter and compare it with the value v specified, returns true if the parameter applied is greater than or equals to v
    
    Type Parameters:
    
    T - the type of the value and parameter
    
    Parameters:
    
    v - the value to be compare with the function parameter
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - greaterThanOrEqualsTo
```
public static <T extends Comparable<T>> Lang.F1<T,Boolean> greaterThanOrEqualsTo(T v)
```
    Alias of gte(Comparable)
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    v - the value used to check against function argument
    
    Returns:
    
    a function that check if an object is greater than or equals to the value specified
    
    Since:
    
    0.2
  - lte
```
public static <T extends Comparable<T>> Lang.F1<T,Boolean> lte(T v)
```
    Returns a function that apply to one parameter and compare it with the value v specified, returns true if the parameter applied is less than or equals to v
    
    Type Parameters:
    
    T - the type of the value and parameter
    
    Parameters:
    
    v - the value to be compare with the function parameter
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - lessThanOrEqualsTo
```
public static <T extends Comparable<T>> Lang.F1<T,Boolean> lessThanOrEqualsTo(T v)
```
    Alias of lte(Comparable)
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    v - the value to be used to check agains function arugment
    
    Returns:
    
    a function that check if a object is lesser than or equals to specified value
    
    Since:
    
    0.2
  - lt
```
public static <T extends Comparable<T>> Lang.F2<T,T,Boolean> lt()
```
    Returns a function that check if a value is less than another one. This is the type safe version of LESS_THAN
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - lessThan
```
public static <T extends Comparable<T>> Lang.F2<T,T,Boolean> lessThan()
```
    Alias of lt()
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - lte
```
public static <T extends Comparable<T>> Lang.F2<T,T,Boolean> lte()
```
    Returns a function that check if a value is less than or equals to another one. This is the type safe version of LESS_THAN_OR_EQUAL_TO
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - lessThanOrEqualsTo
```
public static <T extends Comparable<T>> Lang.F2<T,T,Boolean> lessThanOrEqualsTo()
```
    Alias of lte()
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - gt
```
public static <T extends Comparable<T>> Lang.F2<T,T,Boolean> gt()
```
    Returns a function that check if a value is less than another one.
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - greaterThan
```
public static <T extends Comparable<T>> Lang.F2<T,T,Boolean> greaterThan()
```
    Alias of gt()
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - gte
```
public static <T extends Comparable<T>> Lang.F2<T,T,Boolean> gte()
```
    Returns a function that check if a value is greater than or equals to another one. This is the type safe version of GREATER_THAN_OR_EQUAL_TO
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - greaterThanOrEqualsTo
```
public static <T extends Comparable<T>> Lang.F2<T,T,Boolean> greaterThanOrEqualsTo()
```
    Alias of gte()
    
    Type Parameters:
    
    T - the element type
    
    Returns:
    
    a function that check if one element is greater than or equals to another
    
    Since:
    
    0.2
  - lt
```
public static <T> Lang.F2<T,T,Boolean> lt(Comparator<? super T> c)
```
    Returns a function that check if a value is less than another one using the Comparator specified
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - lessThan
```
public static <T> Lang.F2<T,T,Boolean> lessThan(Comparator<? super T> c)
```
    Alias of lt(java.util.Comparator)
    
    Type Parameters:
    
    T - element type
    
    Parameters:
    
    c - a comparator function
    
    Returns:
    
    a function that use c to check if an element is lesser than another
    
    Since:
    
    0.2
  - gt
```
public static <T> Lang.F2<T,T,Boolean> gt(Comparator<? super T> c)
```
    Returns a function that check if a value is less than another one using the Comparator specified
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - greaterThan
```
public static <T> Lang.F2<T,T,Boolean> greaterThan(Comparator<? super T> c)
```
    Alias of gt(java.util.Comparator)
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - lte
```
public static <T> Lang.F2<T,T,Boolean> lte(Comparator<? super T> c)
```
    Returns a function that check if a value is less than or equals to another one using the Comparator specified
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - lessThanOrEqualsTo
```
public static <T> Lang.F2<T,T,Boolean> lessThanOrEqualsTo(Comparator<? super T> c)
```
    Alias of lte(java.util.Comparator)
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    c - a comparator function
    
    Returns:
    
    a function that use c to check if an element is lesser than or equals to another
    
    Since:
    
    0.2
  - gte
```
public static <T> Lang.F2<T,T,Boolean> gte(Comparator<? super T> c)
```
    Returns a function that check if a value is greater than or equals to another one using the Comparator specified
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - greaterThanOrEqualsTo
```
public static <T> Lang.F2<T,T,Boolean> greaterThanOrEqualsTo(Comparator<? super T> c)
```
    Alias of gte(java.util.Comparator)
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    c - a comparator function
    
    Returns:
    
    a function that use c to check if an element is greater than or equals to another
    
    Since:
    
    0.2
  - lt
```
public static <T> Lang.F2<T,T,Boolean> lt(Lang.Func2<? super T,? super T,Integer> c)
```
    Returns a function that check if a value is less than another one using the Comparator specified
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - lessThan
```
public static <T> Lang.F2<T,T,Boolean> lessThan(Lang.Func2<? super T,? super T,Integer> c)
```
    Alias of lt(java.util.Comparator)
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    c - a comparator function
    
    Returns:
    
    a function that use function c to check if an element is lesser than another
    
    Since:
    
    0.2
  - gt
```
public static <T> Lang.F2<T,T,Boolean> gt(Lang.Func2<? super T,? super T,Integer> c)
```
    Returns a function that check if a value is less than another one using the Comparator specified
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - greaterThan
```
public static <T> Lang.F2<T,T,Boolean> greaterThan(Lang.Func2<? super T,? super T,Integer> c)
```
    Alias of gt(java.util.Comparator)
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    c - a comparator function
    
    Returns:
    
    a function that use comparator function c to check if an object is greater than another
    
    Since:
    
    0.2
  - lte
```
public static <T> Lang.F2<T,T,Boolean> lte(Lang.Func2<? super T,? super T,Integer> c)
```
    Returns a function that check if a value is less than or equals to another one using the Comparator specified
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - lessThanOrEqualsTo
```
public static <T> Lang.F2<T,T,Boolean> lessThanOrEqualsTo(Lang.Func2<? super T,? super T,Integer> c)
```
    Alias of lte(java.util.Comparator)
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - gte
```
public static <T> Lang.F2<T,T,Boolean> gte(Lang.Func2<? super T,? super T,Integer> c)
```
    Returns a function that check if a value is greater than or equals to another one using the Comparator specified
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - greaterThanOrEqualsTo
```
public static <T> Lang.F2<T,T,Boolean> greaterThanOrEqualsTo(Lang.Func2<? super T,? super T,Integer> c)
```
    Alias of gte(java.util.Comparator)
    
    Type Parameters:
    
    T - The type of the value been compared, should implements Comparable
    
    Parameters:
    
    c - The comparator that can compare the value
    
    Returns:
    
    the function that do the comparison
    
    Since:
    
    0.2
  - eq
```
public static <P1,P2> Lang.F2<P1,P2,Boolean> eq()
```
    The type-safe version of EQ
    
    Type Parameters:
    
    P1 - the type of the first argument
    
    P2 - the type of the second argument
    
    Returns:
    
    a type-safe function that check equility of two objects
    
    Since:
    
    0.2
  - equal
```
public static <P1,P2> Lang.F2<P1,P2,Boolean> equal()
```
    Alias of eq()
    
    Type Parameters:
    
    P1 - the type of the first argument
    
    P2 - the type of the second argument
    
    Returns:
    
    a type-safe function that check equility of two objects
    
    Since:
    
    0.2
  - eq
```
public static <P> Lang.Predicate<P> eq(P element)
```
    Returns a Lang.Predicate that checkes if the argument equals to the element specified
    
    Type Parameters:
    
    P - the element type
    
    Parameters:
    
    element - the object to be checked with argument when applying the function
    
    Returns:
    
    the function that returns true if the argument equals with the element specified or false otherwise
  - ne
```
public static <P1,P2> Lang.F2<P1,P2,Boolean> ne()
```
    The type-safe version of NE
    
    Type Parameters:
    
    P1 - type of the first argument
    
    P2 - type of the second argument
    
    Returns:
    
    the type-safe version of NE
    
    Since:
    
    0.2
  - notEqual
```
public static <P1,P2> Lang.F2<P1,P2,Boolean> notEqual()
```
    Alias of ne()
    
    Type Parameters:
    
    P1 - type of the first argument
    
    P2 - type of the second argument
    
    Returns:
    
    the type-safe version of NE
    
    Since:
    
    0.2
  - naturalOrder
```
public static <T extends Comparable<T>> Lang.Comparator<T> naturalOrder()
```
  - reverseOrder
```
public static <T extends Comparable<? super T>> Lang.Comparator<T> reverseOrder()
```
  - reverse
```
public static <T> Lang.Comparator<T> reverse(Comparator<? super T> c)
```
  - comparing
```
public static <T,U extends Comparable<? super U>> Lang.Comparator<T> comparing(Lang.Function<? super T,? extends U> keyExtractor)
```
  - comparing
```
public static <T,U> Lang.Comparator<T> comparing(Lang.Function<? super T,? extends U> keyExtractor,
                                                 Comparator<? super U> keyComparator)
```
    Construct a Comparator with a function to extract the key of type U from given object of type T and a comparator to compare type U
    
    Type Parameters:
    
    T - the type of the object instance
    
    U - the type of the key extract from T
    
    Parameters:
    
    keyExtractor - the function to extract the key for comparison
    
    keyComparator - the Comparator that compares type U (the key type)
    
    Returns:
    
    a comparator that compares type T objects
  - hc
```
public static <T> Lang.F1<T,Integer> hc()
```
    The type-safe version of HASH_CODE
    
    Type Parameters:
    
    T - specifies the generic type of the argument passed to the returned function
    
    Returns:
    
    a function of type F1<T, Integer> that takes type T argument and returns Object.hashCode() of the argument
    
    Since:
    
    0.2
  - asString
```
public static <T> Lang.F1<T,String> asString()
```
    A type-safe version of AS_STRING. It returns a function that takes argument of type T and returns a String by calling Object.toString() function on the argument
    
    Type Parameters:
    
    T - the generic type T of the returning function
    
    Returns:
    
    a function of type F1<T, String>
    
    Since:
    
    0.2
  - asString
```
public static <T> Lang.F1<T,String> asString(Class<T> tClass)
```
    Type safe version of AS_STRING. It returns a function that takes argument of type T and returns a String by calling Object.toString() function on the argument
    
    Type Parameters:
    
    T - the generic type T of the returning function
    
    Parameters:
    
    tClass - the class specify the generic type
    
    Returns:
    
    a function of type F1<T, String>
  - propertyExtractor
```
public static <BEAN> Lang.Transformer<BEAN,Object> propertyExtractor(String property)
```
  - fieldWithAnnotation
```
public static Lang.Predicate<Field> fieldWithAnnotation(Class<? extends Annotation> annoClass)
```
    Returns a predicate function that when applied to a Field type object, returns true if the field has specified annotation presented
    
    Parameters:
    
    annoClass - the annotation
    
    Returns:
    
    a predicate function as described above

Enum Lang.F

Field Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Field Detail

TRUE

FALSE

IS_NULL

NOT_NULL

IDENTITY

LESS_THAN

GREATER_THAN

LESS_THAN_OR_EQUAL_TO

GREATER_THAN_OR_EQUAL_TO

EQ

EQUAL

NE

NOT_EQUAL

NATURAL_ORDER

REVERSE_ORDER

HASH_CODE

AS_STRING

NON_STATIC_FIELD

Method Detail

values

valueOf

breakIf

breakIf

breakIf

breakIf

breakIf

breakIf

breakIf

breakIf

breakIf

breakIf

and

and

or

or

any

any

none

none

not

invert

negate

negate

negate

negate

negate

negate

provides

yes

no

isNull

isNull

requireNotNull

identity

identity

lt

lessThan

gt

greaterThan

gte

greaterThanOrEqualsTo

lte

lessThanOrEqualsTo

lt

lessThan

lte

lessThanOrEqualsTo

gt

greaterThan

gte

greaterThanOrEqualsTo

lt

lessThan

gt