de.caff.generics.function

Interface FragileProcedure0<E extends java.lang.Exception>

Type Parameters:

E - exception thrown by the procedure

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 FragileProcedure0<E extends java.lang.Exception>

Function without return and with no paramete, but a possible expectionr. In a pure functional world this is useless, but in the real world it can be useful sometimes.

Author:

Rammi

See Also:

Procedure0, FragileProcedure1, FragileProcedure2, FragileProcedure3

Field Summary

Fields

Modifier and Type	Field and Description
static FragileProcedure0<?>	NULL Fragile procedure with no arguments which does nothing, not even throw.

Method Summary

Modifier and Type	Method and Description
void	apply() Run the function.
default <Any> FragileProcedure1<E,Any>	asProcedure1() Return a view of this procedure which accepts an additional but ignored parameter.
static <X extends java.lang.Exception> FragileProcedure0<X>	empty() Return a zero argument procedure which does nothing, not even throw.
default Procedure0	nonFragile() Convert this to a non-fragile procedure which does not throw a checked exception.
default Procedure0	nonFragileX(java.util.function.Consumer<? super E> exceptionHandler) Convert this to a non-fragile procedure which does not a checked exception.

Field Detail

NULL

@NotNull
static final FragileProcedure0<?> NULL

Fragile procedure with no arguments which does nothing, not even throw. Use empty() instead.

Method Detail

apply

void apply()
    throws E extends java.lang.Exception

Run the function.

Throws:

E - exception

E extends java.lang.Exception

asProcedure1

@NotNull
default <Any> FragileProcedure1<E,Any> asProcedure1()

Return a view of this procedure which accepts an additional but ignored parameter.

This is sometimes useful when another functional signature is required.

   
   FragileProcedure0<IOException> foo = () -> is.write(0xFF);
   FragileProcedure1<IOException, Integer> bar = foo.asProcedure1();
   FragileProcedure1<IOException, String>  baz = foo.asProcedure1();
   
 

Type Parameters:

Any - parameter type of returned procedure

Returns:

procedure with one (ignored) parameter

nonFragile

@NotNull
default Procedure0 nonFragile()

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

Returns:

non-fragile function

See Also:

Procedure0.nonFragile(FragileProcedure0)

nonFragileX

@NotNull
default Procedure0 nonFragileX(@NotNull
                                        java.util.function.Consumer<? super E> exceptionHandler)

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

Parameters:

exceptionHandler - handler called when an exception is encountered. It may either ignore it, throw an unchecked exception, or collect the exceptions

Returns:

non-fragile function

See Also:

Procedure0.nonFragileX(FragileProcedure0, Consumer)

empty

@NotNull
static <X extends java.lang.Exception> FragileProcedure0<X> empty()

Return a zero argument procedure which does nothing, not even throw.

Type Parameters:

X - exception type

Returns:

empty do-nothing procedure