Base (Motif 0.8 API)

java.lang.Object
- no.motif.Base

```
public final class Base
extends Object
```
Basic functions.

See Also:

Predicate, Fn

Field Summary

Fields
Modifier and Type	Field and Description
`static Fn<Object,Integer>`	`hashCode` Yields the `hashCode` for objects, or 0 if `null`.
`static Predicate<Object>`	`isNull` Yields `true` for `null` values.
`static Predicate<Object>`	`notNull` Yields `true` for all non-`null` values.
`static Fn<Object,String>`	`toString` Yields the `string representation` of any object.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <E,I extends Iterable<E>> Predicate<I>`	`all(Predicate<? super E> predicate)` Evaluate if all elements satisfies a predicate, i.e.
`static ConjunctionPremise`	`allOf(Fn0<Boolean>... premises)` Compose an AND-expression of several `Fn0<Boolean>s`.
`static <T> Conjunction<T>`	`allOf(Predicate<? super T>... predicates)` Compose an AND-expression of several predicates.
`static <T> Predicate<T>`	`always(boolean bool)` Create a predicate which always yields the given `boolean` value.
`static <I1,I2,V> Constant<I1,I2,V>`	`always(V value)` Create a function which always yields the given value.
`static <I1,I2,O> Throw<I1,I2,O>`	`alwaysThrow(Exception ex)` Create a function which always throw the given exception.
`static DisjunctionPremise`	`anyOf(Fn0<Boolean>... premises)` Compose an OR-expression of several `Fn0<Boolean>s`.
`static <T> Disjunction<T>`	`anyOf(Predicate<? super T>... predicates)` Compose an OR-expression of several predicates.
`static <T> Disjunction<T>`	`anyOf(T... objects)` Shorthand for `anyOf(equalTo(o1), equalTo(o2), ..., equalTo(on))`
`static ConjunctionPremise`	`both(Fn0<Boolean> premise)` Create a AND-expression of several `Fn0<Boolean>s`, starting with the one given to this method.
`static <T> Conjunction<T>`	`both(Predicate<T> predicate)` Create a AND-expression of several predicates, starting with the one given to this method.
`static <T> Predicate<T>`	`containedIn(Iterable<? extends T> iterable)` Evaluates if objects are contained in the given `Iterable`.
`static DisjunctionPremise`	`either(Fn0<Boolean> premise)` Create a OR-expression of several `Fn0<Boolean>s`, starting with the one given to this method.
`static <T> Disjunction<T>`	`either(Predicate<T> predicate)` Create a OR-expression of several predicates, starting with the one given to this method.
`static <T> Disjunction<T>`	`either(T o)` Shorthand for `either(equalTo(o))`.
`static <T extends Comparable<? super T>> Predicate<T>`	`equalOrGreaterThan(T value)` Predicate evaluating if values are equal to or greater than a given value.
`static <T extends Comparable<? super T>> Predicate<T>`	`equalOrLessThan(T value)` Predicate evaluating if values are equal to or less than a given value.
`static <T> Predicate<T>`	`equalTo(Fn0<? super T> value)` Equality predicate, checks if values are equal to the value computed from the given `Fn0`.
`static <T> Predicate<T>`	`equalTo(T value)` Equality predicate, checks if values are equal to the given value.
`static <E,I extends Iterable<E>> Predicate<I>`	`exists(E element)` Shorthand for `exists(equalTo(element))`
`static <E,I extends Iterable<E>> Predicate<I>`	`exists(Predicate<? super E> element)` Evaluate if an element exists, i.e.
`static <T,E> Fn<T,Elements<E>>`	`extract(Fn<? super T,? extends E>... extractors)` A function to extract/derive several values from one object.
`static <V> DoChain<V>`	`first(Do<V> action)` Chain several `Do`s to be executed in sequence.
`static <I,O> FnChain<I,O>`	`first(Fn<I,O> fn)` Compose a chain of several functions into one `Fn`, where the result of each function is passed to its successor, and the last will yield the actual result of the chain.
`static <I1,I2,O> Fn2Chain<I1,I2,O,O>`	`first(Fn2<I1,I2,O> fn2)` Compose a chain of several functions into one `Fn2`, where the result of each function is passed to its successor, and the last will yield the actual result of the chain.
`static RunnableChain`	`first(Runnable runnable)` Compose several `Runnable`s as a single Runnable which will execute the given Runnables in sequence.
`static <T extends Comparable<? super T>> Predicate<T>`	`greaterThan(T value)` Predicate evaluating if values are greater than a given value.
`static <T> Predicate<T>`	`is(T value)` A synonym for `equalTo(Object)`.
`static <T extends Comparable<? super T>> Predicate<T>`	`lessThan(T value)` Predicate evaluating if values are less than a given value.
`static <T> Predicate<T>`	`not(Predicate<T> p)` Negates a predicate.
`static <T> Predicate<T>`	`not(T o)` Shorthand for `not(equalTo(o))`.
`static <I,O> When<I,O>`	`when(Predicate<? super I> condition, Fn<? super I,? extends O> fn)` Creates a "guarded" `Fn` using a `Predicate` to evaluate if the argument should be passed to the wrapped `Fn`.
`static <T,P> Predicate<T>`	`where(Fn<T,P> fn, Predicate<? super P> predicate)` Compose a predicate from taking the result of a function and apply it to another predicate.

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

- Field Detail
  - isNull
```
public static final Predicate<Object> isNull
```
    Yields true for null values.
  - notNull
```
public static final Predicate<Object> notNull
```
    Yields true for all non-null values.
  - toString
```
public static final Fn<Object,String> toString
```
    Yields the string representation of any object.
  - hashCode
```
public static final Fn<Object,Integer> hashCode
```
    Yields the hashCode for objects, or 0 if null.
- Method Detail
  - not
```
public static <T> Predicate<T> not(T o)
```
    Shorthand for not(equalTo(o)).
    
    See Also:
    
    not(Predicate), equalTo(Object)
  - not
```
public static <T> Predicate<T> not(Predicate<T> p)
```
    Negates a predicate.
    
    Parameters:
    
    p - The predicate to negate.
    
    Returns:
    
    The new predicate.
  - where
```
public static <T,P> Predicate<T> where(Fn<T,P> fn,
                                       Predicate<? super P> predicate)
```
    Compose a predicate from taking the result of a function and apply it to another predicate.
```
 fn(T) ∈ P
 p(P) ∈ {true, false}
 ƒ(T) = p(fn(T)) ∈ {true, false}
 
```
    This simple composition enables one to focus on writing functions for your particular domain, and reusing basic predicates provided by Motif.
    Type Parameters:
    
    P - The type of the predicate evaluating the function result.
    
    T - The type of the resulting predicate.
    
    Parameters:
    
    fn - The function which result will be evaluated by the predicate. Takes an argument of T
    
    predicate - Evaluates the result from the function, i.e. a value of P
    
    Returns:
    
    A predicate of T
  - both
```
public static <T> Conjunction<T> both(Predicate<T> predicate)
```
    Create a AND-expression of several predicates, starting with the one given to this method.
    
    Parameters:
    
    predicate - The first predicate.
    
    Returns:
    
    a new predicate which may be used to build up an AND-expression by chaining the and(anotherPredicate) method.
    
    See Also:
    
    Conjunction, allOf(Predicate...)
  - both
```
public static ConjunctionPremise both(Fn0<Boolean> premise)
```
    Create a AND-expression of several Fn0<Boolean>s, starting with the one given to this method.
    
    Parameters:
    
    premise - The first Fn0<Boolean>.
    
    Returns:
    
    a new Fn0<Boolean> which may be used to build up an AND-expression by chaining the and(anotherPremise) method.
    
    See Also:
    
    ConjunctionPremise
  - allOf
```
@SafeVarargs
public static <T> Conjunction<T> allOf(Predicate<? super T>... predicates)
```
    Compose an AND-expression of several predicates.
    
    Parameters:
    
    predicates - the predicates.
    
    Returns:
    
    a new predicate which is the conjunction (AND) of the given predicates.
    
    See Also:
    
    Conjunction
  - allOf
```
@SafeVarargs
public static ConjunctionPremise allOf(Fn0<Boolean>... premises)
```
    Compose an AND-expression of several Fn0<Boolean>s.
    
    Parameters:
    
    premises - the Fn0<Boolean>s.
    
    Returns:
    
    a new Fn0<Boolean> which is the conjunction (AND) of the given premises.
    
    See Also:
    
    ConjunctionPremise
  - either
```
public static <T> Disjunction<T> either(T o)
```
    Shorthand for either(equalTo(o)).
    
    See Also:
    
    either(Predicate), Disjunction
  - either
```
public static <T> Disjunction<T> either(Predicate<T> predicate)
```
    Create a OR-expression of several predicates, starting with the one given to this method.
    
    Parameters:
    
    predicate - The first predicate.
    
    Returns:
    
    a new predicate which may be used to build up an OR-expression by chaining the or(anotherPredicate) method.
    
    See Also:
    
    Disjunction, anyOf(Predicate...)
  - either
```
public static DisjunctionPremise either(Fn0<Boolean> premise)
```
    Create a OR-expression of several Fn0<Boolean>s, starting with the one given to this method.
    
    Parameters:
    
    premise - The first Fn0<Boolean>.
    
    Returns:
    
    a new Fn0<Boolean> which may be used to build up an OR-expression by chaining the or(anotherPremise) method.
    
    See Also:
    
    DisjunctionPremise
  - anyOf
```
@SafeVarargs
public static <T> Disjunction<T> anyOf(T... objects)
```
    Shorthand for anyOf(equalTo(o1), equalTo(o2), ..., equalTo(on))
    
    Parameters:
    
    objects - the candidate objects for equivalence check.
    
    See Also:
    
    Disjunction
  - anyOf
```
@SafeVarargs
public static <T> Disjunction<T> anyOf(Predicate<? super T>... predicates)
```
    Compose an OR-expression of several predicates.
    
    Parameters:
    
    predicates - the predicates.
    
    Returns:
    
    a new predicate which is the disjunction (OR) of the given predicates.
    
    See Also:
    
    Disjunction
  - anyOf
```
@SafeVarargs
public static DisjunctionPremise anyOf(Fn0<Boolean>... premises)
```
    Compose an OR-expression of several Fn0<Boolean>s.
    
    Parameters:
    
    premises - the Fn0<Boolean>s.
    
    Returns:
    
    a new Fn0<Boolean>s which is the disjunction (OR) of the given premises.
    
    See Also:
    
    DisjunctionPremise
  - all
```
public static <E,I extends Iterable<E>> Predicate<I> all(Predicate<? super E> predicate)
```
    Evaluate if all elements satisfies a predicate, i.e. the Universal quantifier function. Note that the predicate
    
    Parameters:
    
    predicate - The predicate which will evaluate all elements.
    
    Returns:
    
    a predicate which evaluates to true if all elements evaluates to true by the given predicate, false if any evaluates to false.
  - exists
```
public static <E,I extends Iterable<E>> Predicate<I> exists(E element)
```
    Shorthand for exists(equalTo(element))
    
    Parameters:
    
    element - The element to look for in an Iterable.
    
    Returns:
    
    a predicate which evaluates to true if an element equal to the given element is found, false otherwise.
  - exists
```
public static <E,I extends Iterable<E>> Predicate<I> exists(Predicate<? super E> element)
```
    Evaluate if an element exists, i.e. the Existential quantifier function.
    
    Parameters:
    
    element - The existance-deciding predicate.
    
    Returns:
    
    a predicate which evaluates to true if any element evaluates to true by the given predicate, false otherwise.
  - is
```
public static <T> Predicate<T> is(T value)
```
    A synonym for equalTo(Object).
  - equalTo
```
public static <T> Predicate<T> equalTo(T value)
```
    Equality predicate, checks if values are equal to the given value.
    
    Parameters:
    
    value - the value the predicate should check for equality against.
  - equalTo
```
public static <T> Predicate<T> equalTo(Fn0<? super T> value)
```
    Equality predicate, checks if values are equal to the value computed from the given Fn0.
    
    Parameters:
    
    value - the Fn0 which will compute the value to check for equality against on each application of the predicate.
  - lessThan
```
public static <T extends Comparable<? super T>> Predicate<T> lessThan(T value)
```
    Predicate evaluating if values are less than a given value.
    
    Parameters:
    
    value - the right operand, i.e. the predicate will evaluate if values are less than this value.
    
    Returns:
    
    the "< value" predicate
  - equalOrLessThan
```
public static <T extends Comparable<? super T>> Predicate<T> equalOrLessThan(T value)
```
    Predicate evaluating if values are equal to or less than a given value.
    
    Parameters:
    
    value - the right operand, i.e. the predicate will evaluate if values are equal to or less than this value.
    
    Returns:
    
    the "=< value" predicate
  - greaterThan
```
public static <T extends Comparable<? super T>> Predicate<T> greaterThan(T value)
```
    Predicate evaluating if values are greater than a given value.
    
    Parameters:
    
    value - the right operand, i.e. the predicate will evaluate if values are greater than this value.
    
    Returns:
    
    the "> value" predicate
  - equalOrGreaterThan
```
public static <T extends Comparable<? super T>> Predicate<T> equalOrGreaterThan(T value)
```
    Predicate evaluating if values are equal to or greater than a given value.
    
    Parameters:
    
    value - the right operand, i.e. the predicate will evaluate if values are equal to or greater than this value.
    
    Returns:
    
    the ">= value" predicate
  - extract
```
@SafeVarargs
public static <T,E> Fn<T,Elements<E>> extract(Fn<? super T,? extends E>... extractors)
```
    A function to extract/derive several values from one object. The result of the extraction is an Elementss container of the least common supertype of the extractor Fns' return types.
    
    Parameters:
    
    extractors - the Fns which will extract values from each object passed to the function.
    
    Returns:
    
    the composed function which yields.
  - when
```
public static <I,O> When<I,O> when(Predicate<? super I> condition,
                                   Fn<? super I,? extends O> fn)
```
    Creates a "guarded" Fn using a Predicate to evaluate if the argument should be passed to the wrapped Fn. The function created by this method is essentially this ternary expression:
```
 condition(v) ? f(v) : null;
```
    To fall back to another value than null, call either .orElse(Fn) or .orElse(other) on the returned object.
    Parameters:
    
    condition - Only when this evaluates to true will the function argument be applied to the given Fn.
    
    fn - The Fn to apply if condition evaluates to true
  - first
```
public static final <I,O> FnChain<I,O> first(Fn<I,O> fn)
```
    Compose a chain of several functions into one Fn, where the result of each function is passed to its successor, and the last will yield the actual result of the chain. Use .then(Fn) to append functions to the chain.
    Note: The chain does no internal inspection of the intermediate results passed to the next function, which means that any function which may return null, must have a null-safe successor function.
    
    Parameters:
    
    fn - The first function in the chain.
    
    Returns:
    
    the given function as the first function in a chain.
  - first
```
public static final <I1,I2,O> Fn2Chain<I1,I2,O,O> first(Fn2<I1,I2,O> fn2)
```
    Compose a chain of several functions into one Fn2, where the result of each function is passed to its successor, and the last will yield the actual result of the chain. Use .then(Fn) to append functions to the chain.
    Note: The chain does no inspection of the intermediate results passed to the next function, which means that any function which may return null, must have a null-safe successor function.
    
    Parameters:
    
    fn2 - The first function in the chain.
    
    Returns:
    
    the given function as the first function in a chain.
  - first
```
public static final RunnableChain first(Runnable runnable)
```
    Compose several Runnables as a single Runnable which will execute the given Runnables in sequence.
    
    Parameters:
    
    runnable - The first Runnable.
    
    Returns:
    
    the given Runnable as the first Runnable in a sequence.
  - first
```
public static <V> DoChain<V> first(Do<V> action)
```
    Chain several Dos to be executed in sequence.
    
    Parameters:
    
    action - The first Do to execute.
    
    Returns:
    
    The given Do as the first Do in a sequence.
  - always
```
public static <I1,I2,V> Constant<I1,I2,V> always(V value)
```
    Create a function which always yields the given value.
    
    Parameters:
    
    value - The value to yield.
  - always
```
public static <T> Predicate<T> always(boolean bool)
```
    Create a predicate which always yields the given boolean value.
    
    Parameters:
    
    bool - The boolean value to yield.
  - alwaysThrow
```
public static <I1,I2,O> Throw<I1,I2,O> alwaysThrow(Exception ex)
```
    Create a function which always throw the given exception. If the exception is not a RuntimeException it will be wrapped as such.
    
    Parameters:
    
    ex - The exception to throw.
  - containedIn
```
public static <T> Predicate<T> containedIn(Iterable<? extends T> iterable)
```
    Evaluates if objects are contained in the given Iterable.

Class Base

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

isNull

notNull

toString

hashCode

Method Detail

not

not

where

both

both

allOf

allOf

either

either

either

anyOf

anyOf

anyOf

all

exists

exists

is

equalTo

equalTo

lessThan

equalOrLessThan

greaterThan

equalOrGreaterThan

extract

when

first

first

first

first

always

always

alwaysThrow

containedIn