Dispatching (emaze-dysfunctional 5.1 API)

java.lang.Object
- net.emaze.dysfunctional.Dispatching

```
public abstract class Dispatching
extends Object
```
curry, mcurry, rcurry, ignore, ignore1st, ignore2nd, ignore3rd, provider, delegate, runnable, action, proposition, predicate.

Author:

rferranti

Constructor Summary

Constructors
Constructor and Description

Dispatching()

Constructors
Constructor and Description
`Dispatching()`

Method Summary

Methods
Modifier and Type	Method and Description
`static <R,T1,T2> BinaryAction<T1,T2>`	`action(BinaryDelegate<R,T1,T2> delegate)` Adapts a binary delegate to a binary action.
`static <R,T> Action<T>`	`action(Delegate<R,T> delegate)` Adapts a delegate to an action.
`static <R,T1,T2,T3> TernaryAction<T1,T2,T3>`	`action(TernaryDelegate<R,T1,T2,T3> delegate)` Adapts a ternary delegate to a ternary action.
`static <T> Runnable`	`curry(Action<T> action, T value)` Partial application of the first parameter to an action.
`static <T1,T2> Action<T2>`	`curry(BinaryAction<T1,T2> action, T1 first)` Partial application of the first parameter to a binary action.
`static <R,T1,T2> Delegate<R,T2>`	`curry(BinaryDelegate<R,T1,T2> delegate, T1 first)` Partial application of the first parameter to a binary delegate.
`static <T1,T2> Predicate<T2>`	`curry(BinaryPredicate<T1,T2> predicate, T1 first)` Partial application of the first parameter to a binary predicate.
`static <R,T> Provider<R>`	`curry(Delegate<R,T> delegate, T value)` Partial application of the parameter to a delegate.
`static <T> Proposition`	`curry(Predicate<T> predicate, T value)` Partial application of the parameter to a predicate.
`static <T1,T2,T3> BinaryAction<T2,T3>`	`curry(TernaryAction<T1,T2,T3> action, T1 first)` Partial application of the first parameter to a ternary action.
`static <R,T1,T2,T3> BinaryDelegate<R,T2,T3>`	`curry(TernaryDelegate<R,T1,T2,T3> delegate, T1 first)` Partial application of the first parameter to a ternary delegate.
`static <T1,T2,T3> BinaryPredicate<T2,T3>`	`curry(TernaryPredicate<T1,T2,T3> predicate, T1 first)` Partial application of the first parameter to a ternary predicate.
`static <T> Delegate<Void,T>`	`delegate(Action<T> adaptee)` Adapts an action to a delegate.
`static <T1,T2> BinaryDelegate<Void,T1,T2>`	`delegate(BinaryAction<T1,T2> adaptee)` Adapts a binary action to a binary delegate.
`static <T1,T2> BinaryDelegate<Boolean,T1,T2>`	`delegate(BinaryPredicate<T1,T2> adaptee)` Adapts a binary predicate to a binary delegate.
`static <T> Delegate<Boolean,T>`	`delegate(Predicate<T> adaptee)` Adapts a predicate to a delegate.
`static <T1,T2,T3> TernaryDelegate<Void,T1,T2,T3>`	`delegate(TernaryAction<T1,T2,T3> adaptee)` Adapts a ternary action to a ternary delegate.
`static <T1,T2,T3> TernaryDelegate<Boolean,T1,T2,T3>`	`delegate(TernaryPredicate<T1,T2,T3> adaptee)` Adapts a ternary predicate to a ternary delegate.
`static <T> Predicate<T>`	`ignore(Proposition proposition, Class<T> ignored)` Adapts a proposition to a predicate by ignoring the passed parameter.
`static <R,T> Delegate<R,T>`	`ignore(Provider<R> provider, Class<T> ignored)` Adapts a provider to a delegate by ignoring the passed parameter.
`static <T> Action<T>`	`ignore(Runnable runnable, Class<T> ignored)` Adapts a runnable to an action by ignoring the parameter.
`static <T1,T2> BinaryAction<T1,T2>`	`ignore1st(Action<T2> action, Class<T1> ignored)` Adapts an action to a binary action by ignoring the first parameter.
`static <T1,T2,T3> TernaryAction<T1,T2,T3>`	`ignore1st(BinaryAction<T2,T3> action, Class<T1> ignored)` Adapts a binary action to a ternary action by ignoring the first parameter.
`static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3>`	`ignore1st(BinaryDelegate<R,T2,T3> delegate, Class<T1> ignored)` Adapts a binary delegate to a ternary delegate by ignoring the first parameter.
`static <T1,T2,T3> TernaryPredicate<T1,T2,T3>`	`ignore1st(BinaryPredicate<T2,T3> predicate, Class<T1> ignored)` Adapts a binary predicate to a ternary predicate by ignoring first parameter.
`static <R,T1,T2> BinaryDelegate<R,T1,T2>`	`ignore1st(Delegate<R,T2> delegate, Class<T1> ignored)` Adapts a delegate to a binary delegate by ignoring the first parameter.
`static <T1,T2> BinaryPredicate<T1,T2>`	`ignore1st(Predicate<T2> predicate, Class<T1> ignored)` Adapts a predicate to a binary predicate by ignoring first parameter.
`static <T1,T2> BinaryAction<T1,T2>`	`ignore2nd(Action<T1> action, Class<T2> ignored)` Adapts an action to a binary action by ignoring the second parameter.
`static <T1,T2,T3> TernaryAction<T1,T2,T3>`	`ignore2nd(BinaryAction<T1,T3> action, Class<T2> ignored)` Adapts a binary action to a ternary action by ignoring the second parameter.
`static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3>`	`ignore2nd(BinaryDelegate<R,T1,T3> delegate, Class<T2> ignored)` Adapts a binary delegate to a ternary delegate by ignoring the second parameter.
`static <T1,T2,T3> TernaryPredicate<T1,T2,T3>`	`ignore2nd(BinaryPredicate<T1,T3> predicate, Class<T2> ignored)` Adapts a binary predicate to a ternary predicate by ignoring second parameter.
`static <R,T1,T2> BinaryDelegate<R,T1,T2>`	`ignore2nd(Delegate<R,T1> delegate, Class<T2> ignored)` Adapts a delegate to a binary delegate by ignoring the second parameter.
`static <T1,T2> BinaryPredicate<T1,T2>`	`ignore2nd(Predicate<T1> predicate, Class<T2> ignored)` Adapts a predicate to a binary predicate by ignoring second parameter.
`static <T1,T2,T3> TernaryAction<T1,T2,T3>`	`ignore3rd(BinaryAction<T1,T2> action, Class<T3> ignored)` Adapts a binary action to a ternary action by ignoring the third parameter.
`static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3>`	`ignore3rd(BinaryDelegate<R,T1,T2> delegate, Class<T3> ignored)` Adapts a binary delegate to a ternary delegate by ignoring the third parameter.
`static <T1,T2,T3> TernaryPredicate<T1,T2,T3>`	`ignore3rd(BinaryPredicate<T1,T2> predicate, Class<T3> ignored)` Adapts a binary predicate to a ternary predicate by ignoring third parameter.
`static <T1,T2,T3> BinaryAction<T1,T3>`	`mcurry(TernaryAction<T1,T2,T3> action, T2 second)` Partial application of the second (middle) parameter to a ternary action.
`static <R,T1,T2,T3> BinaryDelegate<R,T1,T3>`	`mcurry(TernaryDelegate<R,T1,T2,T3> delegate, T2 second)` Partial application of the second (middle) parameter to a ternary delegate.
`static <T1,T2,T3> BinaryPredicate<T1,T3>`	`mcurry(TernaryPredicate<T1,T2,T3> predicate, T2 second)` Partial application of the second (middle) parameter to a ternary predicate.
`static <T1,T2> BinaryPredicate<T1,T2>`	`predicate(BinaryDelegate<Boolean,T1,T2> delegate)` Adapts a binary delegate to a binary predicate
`static <T> Predicate<T>`	`predicate(Delegate<Boolean,T> delegate)` Adapts a delegate to a predicate.
`static <T1,T2,T3> TernaryPredicate<T1,T2,T3>`	`predicate(TernaryDelegate<Boolean,T1,T2,T3> delegate)` Adapts a ternary delegate to a ternary predicate.
`static Proposition`	`proposition(Provider<Boolean> provider)` Adapts a provider to a proposition.
`static <T> Provider<Maybe<T>>`	`provider(Iterator<T> adaptee)` Adapts an iterator to a provider.
`static Provider<Boolean>`	`provider(Proposition adaptee)` Adapts a proposition to a provider.
`static Provider<Void>`	`provider(Runnable adaptee)` Adapts a runnable to a provider.
`static <T1,T2> Action<T1>`	`rcurry(BinaryAction<T1,T2> action, T2 second)` Partial application of the last (rightmost) parameter to a binary action.
`static <R,T1,T2> Delegate<R,T1>`	`rcurry(BinaryDelegate<R,T1,T2> delegate, T2 second)` Partial application of the last (rightmost) parameter to a binary delegate.
`static <T1,T2> Predicate<T1>`	`rcurry(BinaryPredicate<T1,T2> predicate, T2 second)` Partial application of the last (rightmost) parameter to a binary predicate.
`static <T1,T2,T3> BinaryAction<T1,T2>`	`rcurry(TernaryAction<T1,T2,T3> action, T3 third)` Partial application of the last (rightmost) parameter to a ternary action.
`static <R,T1,T2,T3> BinaryDelegate<R,T1,T2>`	`rcurry(TernaryDelegate<R,T1,T2,T3> delegate, T3 third)` Partial application of the last (rightmost) parameter to a ternary delegate.
`static <T1,T2,T3> BinaryPredicate<T1,T2>`	`rcurry(TernaryPredicate<T1,T2,T3> predicate, T3 third)` Partial application of the last (rightmost) parameter to a ternary predicate.
`static <T> Runnable`	`runnable(Provider<T> provider)` Adapts a provider to a runnable.

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

- Constructor Detail
  - Dispatching
```
public Dispatching()
```
- Method Detail
  - curry
```
public static <T> Runnable curry(Action<T> action,
                 T value)
```
    Partial application of the first parameter to an action.
    
    Type Parameters:
    T - the action parameter type
    Parameters:
    action - the action to be curried
    value - the value to be curried
    
    Returns:
    the curried runnable
  - curry
```
public static <T1,T2> Action<T2> curry(BinaryAction<T1,T2> action,
                       T1 first)
```
    Partial application of the first parameter to a binary action.
    
    Type Parameters:
    T1 - the action former parameter type
    T2 - the action latter parameter type
    Parameters:
    action - the binary action to be curried
    first - the value to be curried as first parameter
    
    Returns:
    the curried unary action
  - curry
```
public static <T1,T2,T3> BinaryAction<T2,T3> curry(TernaryAction<T1,T2,T3> action,
                                   T1 first)
```
    Partial application of the first parameter to a ternary action.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    T3 - the action third parameter type
    Parameters:
    action - the ternary action to be curried as first parameter
    first - the value to be curried
    
    Returns:
    the curried binary action
  - curry
```
public static <T> Proposition curry(Predicate<T> predicate,
                    T value)
```
    Partial application of the parameter to a predicate.
    
    Type Parameters:
    T - the predicate parameter type
    Parameters:
    predicate - the predicate to be curried
    value - the value to be curried
    
    Returns:
    the curried proposition
  - curry
```
public static <T1,T2> Predicate<T2> curry(BinaryPredicate<T1,T2> predicate,
                          T1 first)
```
    Partial application of the first parameter to a binary predicate.
    
    Type Parameters:
    T1 - the predicate former parameter type
    T2 - the predicate latter parameter type
    Parameters:
    predicate - the predicate to be curried
    first - the value to be curried as first parameter
    
    Returns:
    the curried predicate
  - curry
```
public static <T1,T2,T3> BinaryPredicate<T2,T3> curry(TernaryPredicate<T1,T2,T3> predicate,
                                      T1 first)
```
    Partial application of the first parameter to a ternary predicate.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    T3 - the predicate third parameter type
    Parameters:
    predicate - the predicate to be curried
    first - the value to be curried as first parameter
    
    Returns:
    the curried binary predicate
  - curry
```
public static <R,T> Provider<R> curry(Delegate<R,T> delegate,
                      T value)
```
    Partial application of the parameter to a delegate.
    
    Type Parameters:
    R - the delegate return type
    T - the delegate parameter type
    Parameters:
    delegate - the delegate to be curried
    value - the value to be curried
    
    Returns:
    the curried provider
  - curry
```
public static <R,T1,T2> Delegate<R,T2> curry(BinaryDelegate<R,T1,T2> delegate,
                             T1 first)
```
    Partial application of the first parameter to a binary delegate.
    
    Type Parameters:
    R - the delegate return type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    Parameters:
    delegate - the delegate to be curried
    first - the value to be curried as first parameter
    
    Returns:
    the curried delegate
  - curry
```
public static <R,T1,T2,T3> BinaryDelegate<R,T2,T3> curry(TernaryDelegate<R,T1,T2,T3> delegate,
                                         T1 first)
```
    Partial application of the first parameter to a ternary delegate.
    
    Type Parameters:
    R - the delegate return type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate to be curried
    first - the value to be curried as first parameter
    
    Returns:
    the curried binary delegate
  - mcurry
```
public static <T1,T2,T3> BinaryAction<T1,T3> mcurry(TernaryAction<T1,T2,T3> action,
                                    T2 second)
```
    Partial application of the second (middle) parameter to a ternary action.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    T3 - the action third parameter type
    Parameters:
    action - the action to be curried
    second - the value to be curried as second parameter
    
    Returns:
    the curried binary action
  - mcurry
```
public static <R,T1,T2,T3> BinaryDelegate<R,T1,T3> mcurry(TernaryDelegate<R,T1,T2,T3> delegate,
                                          T2 second)
```
    Partial application of the second (middle) parameter to a ternary delegate.
    
    Type Parameters:
    R - the delegate return type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate to be curried
    second - the value to be curried as second parameter
    
    Returns:
    the curried binary delegate
  - mcurry
```
public static <T1,T2,T3> BinaryPredicate<T1,T3> mcurry(TernaryPredicate<T1,T2,T3> predicate,
                                       T2 second)
```
    Partial application of the second (middle) parameter to a ternary predicate.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    T3 - the predicate third parameter type
    Parameters:
    predicate - the predicate to be curried
    second - the value to be curried as second parameter
    
    Returns:
    the curried binary predicate
  - rcurry
```
public static <T1,T2> Action<T1> rcurry(BinaryAction<T1,T2> action,
                        T2 second)
```
    Partial application of the last (rightmost) parameter to a binary action.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    Parameters:
    action - the action to be curried
    second - the value to be curried as second parameter
    
    Returns:
    the curried action
  - rcurry
```
public static <T1,T2,T3> BinaryAction<T1,T2> rcurry(TernaryAction<T1,T2,T3> action,
                                    T3 third)
```
    Partial application of the last (rightmost) parameter to a ternary action.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    T3 - the action third parameter type
    Parameters:
    action - the action to be curried
    third - the value to be curried as third parameter
    
    Returns:
    the curried binary action
  - rcurry
```
public static <T1,T2> Predicate<T1> rcurry(BinaryPredicate<T1,T2> predicate,
                           T2 second)
```
    Partial application of the last (rightmost) parameter to a binary predicate.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    Parameters:
    predicate - the predicate to be curried
    second - the value to be curried as second parameter
    
    Returns:
    the curried predicate
  - rcurry
```
public static <T1,T2,T3> BinaryPredicate<T1,T2> rcurry(TernaryPredicate<T1,T2,T3> predicate,
                                       T3 third)
```
    Partial application of the last (rightmost) parameter to a ternary predicate.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    T3 - the predicate third parameter type
    Parameters:
    predicate - the predicate to be curried
    third - the value to be curried as third parameter
    
    Returns:
    the curried binary predicate
  - rcurry
```
public static <R,T1,T2> Delegate<R,T1> rcurry(BinaryDelegate<R,T1,T2> delegate,
                              T2 second)
```
    Partial application of the last (rightmost) parameter to a binary delegate.
    
    Type Parameters:
    R - the delegate return type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    Parameters:
    delegate - the delegate to be curried
    second - the value to be curried as second parameter
    
    Returns:
    the curried delegate
  - rcurry
```
public static <R,T1,T2,T3> BinaryDelegate<R,T1,T2> rcurry(TernaryDelegate<R,T1,T2,T3> delegate,
                                          T3 third)
```
    Partial application of the last (rightmost) parameter to a ternary delegate.
    
    Type Parameters:
    R - the delegate return type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate to be curried
    third - the value to be curried as third parameter
    
    Returns:
    the curried binary delegate
  - ignore
```
public static <T> Predicate<T> ignore(Proposition proposition,
                      Class<T> ignored)
```
    Adapts a proposition to a predicate by ignoring the passed parameter.
    
    Type Parameters:
    T - the predicate parameter type
    Parameters:
    proposition - the proposition to be adapted
    ignored - the adapted predicate parameter type class
    
    Returns:
    the adapted predicate
  - ignore1st
```
public static <T1,T2> BinaryPredicate<T1,T2> ignore1st(Predicate<T2> predicate,
                                       Class<T1> ignored)
```
    Adapts a predicate to a binary predicate by ignoring first parameter.
    
    Type Parameters:
    T1 - the adapted predicate first parameter type
    T2 - the adapted predicate second parameter type
    Parameters:
    predicate - the predicate to be adapted
    ignored - the adapted predicate ignored parameter type class
    
    Returns:
    the adapted binary predicate
  - ignore1st
```
public static <T1,T2,T3> TernaryPredicate<T1,T2,T3> ignore1st(BinaryPredicate<T2,T3> predicate,
                                              Class<T1> ignored)
```
    Adapts a binary predicate to a ternary predicate by ignoring first parameter.
    
    Type Parameters:
    T1 - the adapted predicate first parameter type
    T2 - the adapted predicate second parameter type
    T3 - the adapted predicate third parameter type
    Parameters:
    predicate - the predicate to be adapted
    ignored - the adapted predicate ignored parameter type class
    
    Returns:
    the adapted ternary predicate
  - ignore2nd
```
public static <T1,T2> BinaryPredicate<T1,T2> ignore2nd(Predicate<T1> predicate,
                                       Class<T2> ignored)
```
    Adapts a predicate to a binary predicate by ignoring second parameter.
    
    Type Parameters:
    T1 - the adapted predicate first parameter type
    T2 - the adapted predicate second parameter type
    Parameters:
    predicate - the predicate to be adapted
    ignored - the adapted predicate ignored parameter type class
    
    Returns:
    the adapted binary predicate
  - ignore2nd
```
public static <T1,T2,T3> TernaryPredicate<T1,T2,T3> ignore2nd(BinaryPredicate<T1,T3> predicate,
                                              Class<T2> ignored)
```
    Adapts a binary predicate to a ternary predicate by ignoring second parameter.
    
    Type Parameters:
    T1 - the adapted predicate first parameter type
    T2 - the adapted predicate second parameter type
    T3 - the adapted predicate third parameter type
    Parameters:
    predicate - the predicate to be adapted
    ignored - the adapted predicate ignored parameter type class
    
    Returns:
    the adapted ternary predicate
  - ignore3rd
```
public static <T1,T2,T3> TernaryPredicate<T1,T2,T3> ignore3rd(BinaryPredicate<T1,T2> predicate,
                                              Class<T3> ignored)
```
    Adapts a binary predicate to a ternary predicate by ignoring third parameter.
    
    Type Parameters:
    T1 - the adapted predicate first parameter type
    T2 - the adapted predicate second parameter type
    T3 - the adapted predicate third parameter type
    Parameters:
    predicate - the predicate to be adapted
    ignored - the adapted predicate ignored parameter type class
    
    Returns:
    the adapted ternary predicate
  - ignore
```
public static <T> Action<T> ignore(Runnable runnable,
                   Class<T> ignored)
```
    Adapts a runnable to an action by ignoring the parameter.
    
    Type Parameters:
    T - the adapted action parameter type
    Parameters:
    runnable - the runnable to be adapted
    ignored - the adapted action ignored parameter type class
    
    Returns:
    the adapted action
  - ignore1st
```
public static <T1,T2> BinaryAction<T1,T2> ignore1st(Action<T2> action,
                                    Class<T1> ignored)
```
    Adapts an action to a binary action by ignoring the first parameter.
    
    Type Parameters:
    T1 - the adapted action first parameter type
    T2 - the adapted action second parameter type
    Parameters:
    action - the action to be adapted
    ignored - the adapted action ignored parameter type class
    
    Returns:
    the adapted binary action
  - ignore1st
```
public static <T1,T2,T3> TernaryAction<T1,T2,T3> ignore1st(BinaryAction<T2,T3> action,
                                           Class<T1> ignored)
```
    Adapts a binary action to a ternary action by ignoring the first parameter.
    
    Type Parameters:
    T1 - the adapted action first parameter type
    T2 - the adapted action second parameter type
    T3 - the adapted action third parameter type
    Parameters:
    action - the action to be adapted
    ignored - the adapted action ignored parameter type class
    
    Returns:
    the adapted ternary action
  - ignore2nd
```
public static <T1,T2> BinaryAction<T1,T2> ignore2nd(Action<T1> action,
                                    Class<T2> ignored)
```
    Adapts an action to a binary action by ignoring the second parameter.
    
    Type Parameters:
    T1 - the adapted action first parameter type
    T2 - the adapted action second parameter type
    Parameters:
    action - the action to be adapted
    ignored - the adapted action ignored parameter type class
    
    Returns:
    the adapted binary action
  - ignore2nd
```
public static <T1,T2,T3> TernaryAction<T1,T2,T3> ignore2nd(BinaryAction<T1,T3> action,
                                           Class<T2> ignored)
```
    Adapts a binary action to a ternary action by ignoring the second parameter.
    
    Type Parameters:
    T1 - the adapted action first parameter type
    T2 - the adapted action second parameter type
    T3 - the adapted action third parameter type
    Parameters:
    action - the action to be adapted
    ignored - the adapted action ignored parameter type class
    
    Returns:
    the adapted ternary action
  - ignore3rd
```
public static <T1,T2,T3> TernaryAction<T1,T2,T3> ignore3rd(BinaryAction<T1,T2> action,
                                           Class<T3> ignored)
```
    Adapts a binary action to a ternary action by ignoring the third parameter.
    
    Type Parameters:
    T1 - the adapted action first parameter type
    T2 - the adapted action second parameter type
    T3 - the adapted action third parameter type
    Parameters:
    action - the action to be adapted
    ignored - the adapted action ignored parameter type class
    
    Returns:
    the adapted ternary action
  - ignore
```
public static <R,T> Delegate<R,T> ignore(Provider<R> provider,
                         Class<T> ignored)
```
    Adapts a provider to a delegate by ignoring the passed parameter.
    
    Type Parameters:
    R - the adapted delegate result type
    T - the adapted delegate parameter type
    Parameters:
    provider - the provider to be adapted
    ignored - the adapted delegate ignored parameter type class
    
    Returns:
    the adapted delegate
  - ignore1st
```
public static <R,T1,T2> BinaryDelegate<R,T1,T2> ignore1st(Delegate<R,T2> delegate,
                                          Class<T1> ignored)
```
    Adapts a delegate to a binary delegate by ignoring the first parameter.
    
    Type Parameters:
    R - the adapted delegate result type
    T1 - the adapted delegate first parameter type
    T2 - the adapted delegate second parameter type
    Parameters:
    delegate - the delegate to be adapted
    ignored - the adapted delegate ignored parameter type class
    
    Returns:
    the adapted delegate
  - ignore1st
```
public static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3> ignore1st(BinaryDelegate<R,T2,T3> delegate,
                                                 Class<T1> ignored)
```
    Adapts a binary delegate to a ternary delegate by ignoring the first parameter.
    
    Type Parameters:
    R - the adapted delegate result type
    T1 - the adapted delegate first parameter type
    T2 - the adapted delegate second parameter type
    T3 - the adapted delegate third parameter type
    Parameters:
    delegate - the delegate to be adapted
    ignored - the adapted delegate ignored parameter type class
    
    Returns:
    the adapted delegate
  - ignore2nd
```
public static <R,T1,T2> BinaryDelegate<R,T1,T2> ignore2nd(Delegate<R,T1> delegate,
                                          Class<T2> ignored)
```
    Adapts a delegate to a binary delegate by ignoring the second parameter.
    
    Type Parameters:
    R - the adapted delegate result type
    T1 - the adapted delegate first parameter type
    T2 - the adapted delegate second parameter type
    Parameters:
    delegate - the delegate to be adapted
    ignored - the adapted delegate ignored parameter type class
    
    Returns:
    the adapted delegate
  - ignore2nd
```
public static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3> ignore2nd(BinaryDelegate<R,T1,T3> delegate,
                                                 Class<T2> ignored)
```
    Adapts a binary delegate to a ternary delegate by ignoring the second parameter.
    
    Type Parameters:
    R - the adapted delegate result type
    T1 - the adapted delegate first parameter type
    T2 - the adapted delegate second parameter type
    T3 - the adapted delegate third parameter type
    Parameters:
    delegate - the delegate to be adapted
    ignored - the adapted delegate ignored parameter type class
    
    Returns:
    the adapted delegate
  - ignore3rd
```
public static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3> ignore3rd(BinaryDelegate<R,T1,T2> delegate,
                                                 Class<T3> ignored)
```
    Adapts a binary delegate to a ternary delegate by ignoring the third parameter.
    
    Type Parameters:
    R - the adapted delegate result type
    T1 - the adapted delegate first parameter type
    T2 - the adapted delegate second parameter type
    T3 - the adapted delegate third parameter type
    Parameters:
    delegate - the delegate to be adapted
    ignored - the adapted delegate ignored parameter type class
    
    Returns:
    the adapted delegate
  - provider
```
public static <T> Provider<Maybe<T>> provider(Iterator<T> adaptee)
```
    Adapts an iterator to a provider.
    
    Parameters:
    adaptee - the runnable to be adapted
    
    Returns:
    the adapted provider
  - provider
```
public static Provider<Void> provider(Runnable adaptee)
```
    Adapts a runnable to a provider.
    
    Parameters:
    adaptee - the runnable to be adapted
    
    Returns:
    the adapted provider
  - provider
```
public static Provider<Boolean> provider(Proposition adaptee)
```
    Adapts a proposition to a provider.
    
    Parameters:
    adaptee - the proposition to be adapted
    
    Returns:
    the adapted provider
  - delegate
```
public static <T> Delegate<Void,T> delegate(Action<T> adaptee)
```
    Adapts an action to a delegate.
    
    Type Parameters:
    T - the action parameter type
    Parameters:
    adaptee - the action to be adapted
    
    Returns:
    the adapted delegate
  - delegate
```
public static <T1,T2> BinaryDelegate<Void,T1,T2> delegate(BinaryAction<T1,T2> adaptee)
```
    Adapts a binary action to a binary delegate.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    Parameters:
    adaptee - the action to be adapted
    
    Returns:
    the adapted delegate
  - delegate
```
public static <T1,T2,T3> TernaryDelegate<Void,T1,T2,T3> delegate(TernaryAction<T1,T2,T3> adaptee)
```
    Adapts a ternary action to a ternary delegate.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    T3 - the action third parameter type
    Parameters:
    adaptee - the action to be adapted
    
    Returns:
    the adapted delegate
  - delegate
```
public static <T> Delegate<Boolean,T> delegate(Predicate<T> adaptee)
```
    Adapts a predicate to a delegate.
    
    Type Parameters:
    T - the predicate parameter type
    Parameters:
    adaptee - the predicate to be adapted
    
    Returns:
    the adapted delegate
  - delegate
```
public static <T1,T2> BinaryDelegate<Boolean,T1,T2> delegate(BinaryPredicate<T1,T2> adaptee)
```
    Adapts a binary predicate to a binary delegate.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    Parameters:
    adaptee - the predicate to be adapted
    
    Returns:
    the adapted delegate
  - delegate
```
public static <T1,T2,T3> TernaryDelegate<Boolean,T1,T2,T3> delegate(TernaryPredicate<T1,T2,T3> adaptee)
```
    Adapts a ternary predicate to a ternary delegate.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    T3 - the predicate third parameter type
    Parameters:
    adaptee - the predicate to be adapted
    
    Returns:
    the adapted delegate
  - runnable
```
public static <T> Runnable runnable(Provider<T> provider)
```
    Adapts a provider to a runnable.
    
    Type Parameters:
    T - the provider parameter type
    Parameters:
    provider - the provider to be adapted
    
    Returns:
    the adapted runnable
  - action
```
public static <R,T> Action<T> action(Delegate<R,T> delegate)
```
    Adapts a delegate to an action.
    
    Type Parameters:
    R - the delegate return type
    T - the delegate parameter type
    Parameters:
    delegate - the delegate to be adapted
    
    Returns:
    the adapted action
  - action
```
public static <R,T1,T2> BinaryAction<T1,T2> action(BinaryDelegate<R,T1,T2> delegate)
```
    Adapts a binary delegate to a binary action.
    
    Type Parameters:
    R - the delegate return type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    Parameters:
    delegate - the delegate to be adapted
    
    Returns:
    the adapted action
  - action
```
public static <R,T1,T2,T3> TernaryAction<T1,T2,T3> action(TernaryDelegate<R,T1,T2,T3> delegate)
```
    Adapts a ternary delegate to a ternary action.
    
    Type Parameters:
    R - the delegate return type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate to be adapted
    
    Returns:
    the adapted action
  - proposition
```
public static Proposition proposition(Provider<Boolean> provider)
```
    Adapts a provider to a proposition.
    
    Parameters:
    provider - the provider to be adapted
    
    Returns:
    the adapted proposition
  - predicate
```
public static <T> Predicate<T> predicate(Delegate<Boolean,T> delegate)
```
    Adapts a delegate to a predicate.
    
    Type Parameters:
    T - the delegate parameter type
    Parameters:
    delegate - the delegate to be adapted
    
    Returns:
    the adapted predicate
  - predicate
```
public static <T1,T2> BinaryPredicate<T1,T2> predicate(BinaryDelegate<Boolean,T1,T2> delegate)
```
    Adapts a binary delegate to a binary predicate
    
    Type Parameters:
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    Parameters:
    delegate - the delegate to be adapted
    
    Returns:
    the adapted predicate
  - predicate
```
public static <T1,T2,T3> TernaryPredicate<T1,T2,T3> predicate(TernaryDelegate<Boolean,T1,T2,T3> delegate)
```
    Adapts a ternary delegate to a ternary predicate.
    
    Type Parameters:
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate to be adapted
    
    Returns:
    the adapted predicate

Class Dispatching

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Dispatching

Method Detail

curry

curry

curry

curry

curry

curry

curry

curry

curry

mcurry

mcurry

mcurry

rcurry

rcurry

rcurry

rcurry

rcurry

rcurry

ignore

ignore1st

ignore1st

ignore2nd

ignore2nd

ignore3rd

ignore

ignore1st

ignore1st

ignore2nd

ignore2nd

ignore3rd

ignore

ignore1st

ignore1st

ignore2nd

ignore2nd

ignore3rd

provider

provider

provider

delegate

delegate

delegate

delegate

delegate

delegate

runnable

action

action

action

proposition

predicate

predicate

predicate