de.caff.generics.function

Interface FragileFunction2<R,E extends java.lang.Exception,P1,P2>

Type Parameters:

R - return type

E - exception type

P1 - first parameter type

P2 - second parameter type

All Superinterfaces:

FragileFunction1<R,E,ITuple2<? extends P1,? extends P2>>

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface FragileFunction2<R,E extends java.lang.Exception,P1,P2>
extends FragileFunction1<R,E,ITuple2<? extends P1,? extends P2>>

Function with two parameters, possibly throwing an exception.

Author:

Rammi

Method Summary

Modifier and Type	Method and Description
default R	apply(ITuple2<? extends P1,? extends P2> tuple2) Expand a tuple into the arguments of this function.
R	apply(P1 arg1, P2 arg2) Run the function.
default Function2<R,P1,P2>	nonFragile() Convert this to a non-fragile function which does not throw a checked exception.
default Function2<R,P1,P2>	nonFragile(R fallback) Convert this to a non-fragile function which does not throw a checked exception.
default Function2<R,P1,P2>	nonFragileX(Function3<? extends R,? super E,? super P1,? super P2> exceptionHandler) Convert this to a non-fragile function which does not throw a checked exception.
default FragileFunction1<R,E,P2>	partial1(P1 argument) Get a partially applied function.
default FragileFunction1<R,E,P1>	partial2(P2 argument) Get a partially applied function.

Methods inherited from interface de.caff.generics.function.FragileFunction1

nonFragileX

Method Detail

apply

R apply(P1 arg1,
        P2 arg2)
 throws E extends java.lang.Exception

Run the function.

Parameters:

arg1 - first argument

arg2 - second argument

Returns:

return value

Throws:

E - typed exception

E extends java.lang.Exception

apply

default R apply(@NotNull
                ITuple2<? extends P1,? extends P2> tuple2)
         throws E extends java.lang.Exception

Expand a tuple into the arguments of this function.

Specified by:

apply in interface FragileFunction1<R,E extends java.lang.Exception,ITuple2<? extends P1,? extends P2>>

Parameters:

tuple2 - tuple to expand

Returns:

the result of calling this function with the arguments from the expanded tuple

Throws:

E - typed exception

E extends java.lang.Exception

nonFragile

@NotNull
default Function2<R,P1,P2> nonFragile()

Convert this to a non-fragile function which does not throw a checked exception. This will instead throw an unchecked WrappedFragileException for any checked exception thrown during apply(Object, Object).

Specified by:

nonFragile in interface FragileFunction1<R,E extends java.lang.Exception,ITuple2<? extends P1,? extends P2>>

Returns:

non-fragile function

See Also:

Function2.nonFragile(FragileFunction2)

nonFragile

@NotNull
default Function2<R,P1,P2> nonFragile(R fallback)

Convert this to a non-fragile function which does not throw a checked exception. This will instead return the fallback value. Please note that in this case the exception is completely lost!

Specified by:

nonFragile in interface FragileFunction1<R,E extends java.lang.Exception,ITuple2<? extends P1,? extends P2>>

Parameters:

fallback - fallback value

Returns:

non-fragile function

See Also:

Function2.nonFragile(FragileFunction2, Object)

nonFragileX

@NotNull
default Function2<R,P1,P2> nonFragileX(@NotNull
                                                Function3<? extends R,? super E,? super P1,? super P2> exceptionHandler)

Convert this to a non-fragile function which does not throw a checked exception.

Parameters:

exceptionHandler - handler which can handle the exception how it sees fit. E.g. throw an unchecked exception (compare nonFragile(), return a fallback (compare nonFragile(Object)), or do the latter but also log or collect the exception

Returns:

non-fragile function

See Also:

Function1.nonFragileX(FragileFunction1, BiFunction)

partial1

@NotNull
default FragileFunction1<R,E,P2> partial1(P1 argument)

Get a partially applied function.

Parameters:

argument - value applied for first argument

Returns:

partially evaluated function

partial2

@NotNull
default FragileFunction1<R,E,P1> partial2(P2 argument)

Get a partially applied function.

Parameters:

argument - value applied for second argument

Returns:

partially evaluated function