• Home
• org.eu.zajc
• extended-functions
• 1.5
• source code
• EHandle.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.eu.zajc.ef.EHandle Maven / Gradle / Ivy

// SPDX-License-Identifier: Apache-2.0
/*
 * extended-functions
 * Copyright 2021-2024 Marko Zajc
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.eu.zajc.ef;

import static org.eu.zajc.ef.Utilities.asUnchecked;

import java.util.concurrent.Callable;
import java.util.function.*;

import javax.annotation.Nonnull;

import org.eu.zajc.ef.biconsumer.*;
import org.eu.zajc.ef.biconsumer.except.*;
import org.eu.zajc.ef.bifunction.*;
import org.eu.zajc.ef.bifunction.except.*;
import org.eu.zajc.ef.bipredicate.*;
import org.eu.zajc.ef.bipredicate.except.*;
import org.eu.zajc.ef.consumer.*;
import org.eu.zajc.ef.consumer.execpt.*;
import org.eu.zajc.ef.function.*;
import org.eu.zajc.ef.function.except.*;
import org.eu.zajc.ef.predicate.*;
import org.eu.zajc.ef.predicate.except.*;
import org.eu.zajc.ef.runnable.except.ERunnable;
import org.eu.zajc.ef.supplier.*;
import org.eu.zajc.ef.supplier.except.*;
import org.eu.zajc.ef.triconsumer.*;
import org.eu.zajc.ef.trifunction.*;
import org.eu.zajc.ef.tripredicate.*;
import org.eu.zajc.ef.unary.*;
import org.eu.zajc.ef.unary.except.*;

/**
 * A class containing various helper utilities for exceptionable (E*) functions and
 * {@link Callable} ({@link ESupplier}).
 *
 * @author Marko Zajc
 */
public class EHandle {

	/*
	 * ================== Consumers ==================
	 */

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  Consumer handle(@Nonnull EConsumer handled,
															  @Nonnull BiConsumer handler) {
		return t -> {
			try {
				handled.acceptChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, t);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  Consumer handleThrowing(@Nonnull EConsumer handled,
																						   @Nonnull Function handler) throws X {
		return t -> {
			try {
				handled.acceptChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  Consumer handleThrowing(@Nonnull EConsumer handled) throws E {
		return t -> {
			try {
				handled.acceptChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  BooleanConsumer handle(@Nonnull EBooleanConsumer handled,
															   @Nonnull ObjBooleanConsumer handler) {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  BooleanConsumer handleThrowing(@Nonnull EBooleanConsumer handled,
																							@Nonnull Function handler) throws X {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  BooleanConsumer handleThrowing(@Nonnull EBooleanConsumer handled) throws E {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  ByteConsumer handle(@Nonnull EByteConsumer handled,
															@Nonnull ObjByteConsumer handler) {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ByteConsumer handleThrowing(@Nonnull EByteConsumer handled,
																						 @Nonnull Function handler) throws X {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ByteConsumer handleThrowing(@Nonnull EByteConsumer handled) throws E {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  CharConsumer handle(@Nonnull ECharConsumer handled,
															@Nonnull ObjCharConsumer handler) {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  CharConsumer handleThrowing(@Nonnull ECharConsumer handled,
																						 @Nonnull Function handler) throws X {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  CharConsumer handleThrowing(@Nonnull ECharConsumer handled) throws E {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  IntConsumer handle(@Nonnull EIntConsumer handled,
														   @Nonnull ObjIntConsumer handler) {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  IntConsumer handleThrowing(@Nonnull EIntConsumer handled,
																						@Nonnull Function handler) throws X {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  IntConsumer handleThrowing(@Nonnull EIntConsumer handled) throws E {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  LongConsumer handle(@Nonnull ELongConsumer handled,
															@Nonnull ObjLongConsumer handler) {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  LongConsumer handleThrowing(@Nonnull ELongConsumer handled,
																						 @Nonnull Function handler) throws X {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  LongConsumer handleThrowing(@Nonnull ELongConsumer handled) throws E {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  ShortConsumer handle(@Nonnull EShortConsumer handled,
															 @Nonnull ObjShortConsumer handler) {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ShortConsumer handleThrowing(@Nonnull EShortConsumer handled,
																						  @Nonnull Function handler) throws X {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ShortConsumer handleThrowing(@Nonnull EShortConsumer handled) throws E {
		return p -> {
			try {
				handled.acceptChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/*
	 * ================== BiConsumers ==================
	 */

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  BiConsumer handle(@Nonnull EBiConsumer handled,
																	  @Nonnull TriConsumer handler) {
		return (t, u) -> {
			try {
				handled.acceptChecked(t, u);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, t, u);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  BiConsumer handleThrowing(@Nonnull EBiConsumer handled,
																								   @Nonnull Function handler) throws X {
		return (t, u) -> {
			try {
				handled.acceptChecked(t, u);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  BiConsumer handleThrowing(@Nonnull EBiConsumer handled) throws E {
		return (t, u) -> {
			try {
				handled.acceptChecked(t, u);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  ObjBooleanConsumer handle(@Nonnull EObjBooleanConsumer handled,
																		@Nonnull ObjObjBooleanConsumer handler) {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjBooleanConsumer handleThrowing(@Nonnull EObjBooleanConsumer handled,
																									 @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjBooleanConsumer handleThrowing(@Nonnull EObjBooleanConsumer handled) throws E {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  ObjByteConsumer handle(@Nonnull EObjByteConsumer handled,
																	 @Nonnull ObjObjByteConsumer handler) {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjByteConsumer handleThrowing(@Nonnull EObjByteConsumer handled,
																								  @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjByteConsumer handleThrowing(@Nonnull EObjByteConsumer handled) throws E {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  ObjCharConsumer handle(@Nonnull EObjCharConsumer handled,
																	 @Nonnull ObjObjCharConsumer handler) {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjCharConsumer handleThrowing(@Nonnull EObjCharConsumer handled,
																								  @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjCharConsumer handleThrowing(@Nonnull EObjCharConsumer handled) throws E {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  ObjIntConsumer handle(@Nonnull EObjIntConsumer handled,
																	@Nonnull ObjObjIntConsumer handler) {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjIntConsumer handleThrowing(@Nonnull EObjIntConsumer handled,
																								 @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjIntConsumer handleThrowing(@Nonnull EObjIntConsumer handled) throws E {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  ObjLongConsumer handle(@Nonnull EObjLongConsumer handled,
																	 @Nonnull ObjObjLongConsumer handler) {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjLongConsumer handleThrowing(@Nonnull EObjLongConsumer handled,
																								  @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjLongConsumer handleThrowing(@Nonnull EObjLongConsumer handled) throws E {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 */
	@Nonnull
	public static  ObjShortConsumer handle(@Nonnull EObjShortConsumer handled,
																	  @Nonnull ObjObjShortConsumer handler) {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjShortConsumer handleThrowing(@Nonnull EObjShortConsumer handled,
																								   @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled consumer by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed consumer
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjShortConsumer handleThrowing(@Nonnull EObjShortConsumer handled) throws E {
		return (t, p) -> {
			try {
				handled.acceptChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/*
	 * ================== Functions ==================
	 */

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  Function handle(@Nonnull EFunction handled,
																	@Nonnull BiFunction handler) {
		return t -> {
			try {
				return handled.applyChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, t);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  Function handleThrowing(@Nonnull EFunction handled,
																								 @Nonnull Function handler) throws X {
		return t -> {
			try {
				return handled.applyChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  Function handleThrowing(@Nonnull EFunction handled) throws E {
		return t -> {
			try {
				return handled.applyChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  BooleanFunction handle(@Nonnull EBooleanFunction handled,
																	 @Nonnull ObjBooleanFunction handler) {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  BooleanFunction handleThrowing(@Nonnull EBooleanFunction handled,
																								  @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  BooleanFunction handleThrowing(@Nonnull EBooleanFunction handled) throws E {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  ByteFunction handle(@Nonnull EByteFunction handled,
																  @Nonnull ObjByteFunction handler) {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ByteFunction handleThrowing(@Nonnull EByteFunction handled,
																							   @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ByteFunction handleThrowing(@Nonnull EByteFunction handled) throws E {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  CharFunction handle(@Nonnull ECharFunction handled,
																  @Nonnull ObjCharFunction handler) {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  CharFunction handleThrowing(@Nonnull ECharFunction handled,
																							   @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  CharFunction handleThrowing(@Nonnull ECharFunction handled) throws E {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  IntFunction handle(@Nonnull EIntFunction handled,
																 @Nonnull ObjIntFunction handler) {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  IntFunction handleThrowing(@Nonnull EIntFunction handled,
																							  @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  IntFunction handleThrowing(@Nonnull EIntFunction handled) throws E {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  LongFunction handle(@Nonnull ELongFunction handled,
																  @Nonnull ObjLongFunction handler) {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  LongFunction handleThrowing(@Nonnull ELongFunction handled,
																							   @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  LongFunction handleThrowing(@Nonnull ELongFunction handled) throws E {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  ShortFunction handle(@Nonnull EShortFunction handled,
																   @Nonnull ObjShortFunction handler) {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ShortFunction handleThrowing(@Nonnull EShortFunction handled,
																								@Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ShortFunction handleThrowing(@Nonnull EShortFunction handled) throws E {
		return p -> {
			try {
				return handled.applyChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/*
	 * ================== BiFunctions ==================
	 */

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  BiFunction handle(@Nonnull EBiFunction handled,
																			@Nonnull TriFunction handler) {
		return (t, u) -> {
			try {
				return handled.applyChecked(t, u);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, t, u);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  BiFunction handleThrowing(@Nonnull EBiFunction handled,
																										 @Nonnull Function handler) throws X {
		return (t, u) -> {
			try {
				return handled.applyChecked(t, u);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  BiFunction handleThrowing(@Nonnull EBiFunction handled) throws E {
		return (t, u) -> {
			try {
				return handled.applyChecked(t, u);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  ObjBooleanFunction handle(@Nonnull EObjBooleanFunction handled,
																			  @Nonnull ObjObjBooleanFunction handler) {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjBooleanFunction handleThrowing(@Nonnull EObjBooleanFunction handled,
																										   @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjBooleanFunction handleThrowing(@Nonnull EObjBooleanFunction handled) throws E {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  ObjByteFunction handle(@Nonnull EObjByteFunction handled,
																		   @Nonnull ObjObjByteFunction handler) {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjByteFunction handleThrowing(@Nonnull EObjByteFunction handled,
																										@Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjByteFunction handleThrowing(@Nonnull EObjByteFunction handled) throws E {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  ObjCharFunction handle(@Nonnull EObjCharFunction handled,
																		   @Nonnull ObjObjCharFunction handler) {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjCharFunction handleThrowing(@Nonnull EObjCharFunction handled,
																										@Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjCharFunction handleThrowing(@Nonnull EObjCharFunction handled) throws E {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  ObjIntFunction handle(@Nonnull EObjIntFunction handled,
																		  @Nonnull ObjObjIntFunction handler) {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjIntFunction handleThrowing(@Nonnull EObjIntFunction handled,
																									   @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjIntFunction handleThrowing(@Nonnull EObjIntFunction handled) throws E {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  ObjLongFunction handle(@Nonnull EObjLongFunction handled,
																		   @Nonnull ObjObjLongFunction handler) {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjLongFunction handleThrowing(@Nonnull EObjLongFunction handled,
																										@Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjLongFunction handleThrowing(@Nonnull EObjLongFunction handled) throws E {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  ObjShortFunction handle(@Nonnull EObjShortFunction handled,
																			@Nonnull ObjObjShortFunction handler) {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjShortFunction handleThrowing(@Nonnull EObjShortFunction handled,
																										 @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's return type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjShortFunction handleThrowing(@Nonnull EObjShortFunction handled) throws E {
		return (t, p) -> {
			try {
				return handled.applyChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/*
	 * ================== Predicates ==================
	 */

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  Predicate handle(@Nonnull EPredicate handled,
															   @Nonnull BiPredicate handler) {
		return t -> {
			try {
				return handled.testChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, t);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  Predicate handleThrowing(@Nonnull EPredicate handled,
																							@Nonnull Function handler) throws X {
		return t -> {
			try {
				return handled.testChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  Predicate handleThrowing(@Nonnull EPredicate handled) throws E {
		return t -> {
			try {
				return handled.testChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  BooleanPredicate handle(@Nonnull EBooleanPredicate handled,
																@Nonnull ObjBooleanPredicate handler) {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  BooleanPredicate handleThrowing(@Nonnull EBooleanPredicate handled,
																							 @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  BooleanPredicate handleThrowing(@Nonnull EBooleanPredicate handled) throws E {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  BytePredicate handle(@Nonnull EBytePredicate handled,
															 @Nonnull ObjBytePredicate handler) {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  BytePredicate handleThrowing(@Nonnull EBytePredicate handled,
																						  @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  BytePredicate handleThrowing(@Nonnull EBytePredicate handled) throws E {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  CharPredicate handle(@Nonnull ECharPredicate handled,
															 @Nonnull ObjCharPredicate handler) {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  CharPredicate handleThrowing(@Nonnull ECharPredicate handled,
																						  @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  CharPredicate handleThrowing(@Nonnull ECharPredicate handled) throws E {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  IntPredicate handle(@Nonnull EIntPredicate handled,
															@Nonnull ObjIntPredicate handler) {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  IntPredicate handleThrowing(@Nonnull EIntPredicate handled,
																						 @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  IntPredicate handleThrowing(@Nonnull EIntPredicate handled) throws E {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  LongPredicate handle(@Nonnull ELongPredicate handled,
															 @Nonnull ObjLongPredicate handler) {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  LongPredicate handleThrowing(@Nonnull ELongPredicate handled,
																						  @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  LongPredicate handleThrowing(@Nonnull ELongPredicate handled) throws E {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  ShortPredicate handle(@Nonnull EShortPredicate handled,
															  @Nonnull ObjShortPredicate handler) {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ShortPredicate handleThrowing(@Nonnull EShortPredicate handled,
																						   @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ShortPredicate handleThrowing(@Nonnull EShortPredicate handled) throws E {
		return p -> {
			try {
				return handled.testChecked(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/*
	 * ================== BiPredicates ==================
	 */

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  BiPredicate handle(@Nonnull EBiPredicate handled,
																	   @Nonnull TriPredicate handler) {
		return (t, u) -> {
			try {
				return handled.testChecked(t, u);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, t, u);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  BiPredicate handleThrowing(@Nonnull EBiPredicate handled,
																									@Nonnull Function handler) throws X {
		return (t, u) -> {
			try {
				return handled.testChecked(t, u);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  BiPredicate handleThrowing(@Nonnull EBiPredicate handled) throws E {
		return (t, u) -> {
			try {
				return handled.testChecked(t, u);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  ObjBooleanPredicate handle(@Nonnull EObjBooleanPredicate handled,
																		 @Nonnull ObjObjBooleanPredicate handler) {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjBooleanPredicate handleThrowing(@Nonnull EObjBooleanPredicate handled,
																									  @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjBooleanPredicate handleThrowing(@Nonnull EObjBooleanPredicate handled) throws E {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  ObjBytePredicate handle(@Nonnull EObjBytePredicate handled,
																	  @Nonnull ObjObjBytePredicate handler) {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjBytePredicate handleThrowing(@Nonnull EObjBytePredicate handled,
																								   @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjBytePredicate handleThrowing(@Nonnull EObjBytePredicate handled) throws E {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  ObjCharPredicate handle(@Nonnull EObjCharPredicate handled,
																	  @Nonnull ObjObjCharPredicate handler) {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjCharPredicate handleThrowing(@Nonnull EObjCharPredicate handled,
																								   @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjCharPredicate handleThrowing(@Nonnull EObjCharPredicate handled) throws E {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  ObjIntPredicate handle(@Nonnull EObjIntPredicate handled,
																	 @Nonnull ObjObjIntPredicate handler) {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjIntPredicate handleThrowing(@Nonnull EObjIntPredicate handled,
																								  @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjIntPredicate handleThrowing(@Nonnull EObjIntPredicate handled) throws E {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  ObjLongPredicate handle(@Nonnull EObjLongPredicate handled,
																	  @Nonnull ObjObjLongPredicate handler) {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjLongPredicate handleThrowing(@Nonnull EObjLongPredicate handled,
																								   @Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjLongPredicate handleThrowing(@Nonnull EObjLongPredicate handled) throws E {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 */
	@Nonnull
	public static  ObjShortPredicate handle(@Nonnull EObjShortPredicate handled,
																	   @Nonnull ObjObjShortPredicate handler) {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e, t, p);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ObjShortPredicate handleThrowing(@Nonnull EObjShortPredicate handled,
																									@Nonnull Function handler) throws X {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled predicate by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed predicate
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ObjShortPredicate handleThrowing(@Nonnull EObjShortPredicate handled) throws E {
		return (t, p) -> {
			try {
				return handled.testChecked(t, p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/*
	 * ================== Runnables ==================
	 */

	/**
	 * Handles a generic exception type that may occur in the handled runnable with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed runnable
	 */
	@Nonnull
	public static  Runnable handle(@Nonnull ERunnable handled,
														@Nonnull Consumer handler) {
		return () -> {
			try {
				handled.runChecked();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				handler.accept(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled runnable by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed runnable
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  Runnable handleThrowing(@Nonnull ERunnable handled,
																					 @Nonnull Function handler) throws X {
		return () -> {
			try {
				handled.runChecked();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled runnable by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed runnable
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  Runnable handleThrowing(@Nonnull ERunnable handled) throws E {
		return () -> {
			try {
				handled.runChecked();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/*
	 * ================== Suppliers & Callable ==================
	 */

	/**
	 * Handles any exception type that may occur in the handled callable with a provided
	 * handler.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed callable
	 */
	@Nonnull
	public static  Supplier handle(@Nonnull Callable handled, @Nonnull Function handler) {
		return () -> {
			try {
				return handled.call();
			} catch (Exception e) {
				return handler.apply(e);
			}
		};
	}

	/**
	 * Handles any exception type that may occur in the handled callable by throwing a
	 * different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed callable
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  Supplier handleThrowing(@Nonnull Callable handled,
																	  @Nonnull Function handler) throws X {
		return () -> {
			try {
				return handled.call();
			} catch (Exception e) {
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles any exception type that may occur in the handled callable by throwing it
	 * explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed callable
	 *
	 * @throws Exception
	 *             The checked exception
	 */
	@Nonnull
	public static  Supplier handleThrowing(@Nonnull Callable handled) throws Exception { // NOSONAR
		return () -> {
			try {
				return handled.call();
			} catch (Exception e) {
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  BooleanSupplier handle(@Nonnull EBooleanSupplier handled,
															   @Nonnull Predicate handler) {
		return () -> {
			try {
				return handled.getAsBoolean();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.test(e);
			}
		};
	}

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing a
	 * different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  BooleanSupplier handleThrowing(@Nonnull EBooleanSupplier handled,
																							   @Nonnull Function handler) throws X {
		return () -> {
			try {
				return handled.getAsBoolean();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing it
	 * explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  BooleanSupplier handleThrowing(@Nonnull EBooleanSupplier handled) throws E {
		return () -> {
			try {
				return handled.getAsBoolean();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	// missing: handle EByteSupplier, blocked by: missing ToByteFunction

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing a
	 * different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ByteSupplier handleThrowing(@Nonnull EByteSupplier handled,
																							@Nonnull Function handler) throws X {
		return () -> {
			try {
				return handled.getAsByte();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing it
	 * explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ByteSupplier handleThrowing(@Nonnull EByteSupplier handled) throws E {
		return () -> {
			try {
				return handled.getAsByte();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	// missing: handle ECharSupplier, blocked by: missing ToCharFunction

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing a
	 * different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  CharSupplier handleThrowing(@Nonnull ECharSupplier handled,
																							@Nonnull Function handler) throws X {
		return () -> {
			try {
				return handled.getAsChar();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing it
	 * explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  CharSupplier handleThrowing(@Nonnull ECharSupplier handled) throws E {
		return () -> {
			try {
				return handled.getAsChar();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  IntSupplier handle(@Nonnull EIntSupplier handled,
														   @Nonnull ToIntFunction handler) {
		return () -> {
			try {
				return handled.getAsInt();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.applyAsInt(e);
			}
		};
	}

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing a
	 * different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  IntSupplier handleThrowing(@Nonnull EIntSupplier handled,
																						   @Nonnull Function handler) throws X {
		return () -> {
			try {
				return handled.getAsInt();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing it
	 * explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  IntSupplier handleThrowing(@Nonnull EIntSupplier handled) throws E {
		return () -> {
			try {
				return handled.getAsInt();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	// missing: handle EShortSupplier, blocked by: missing ToShortFunction

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing a
	 * different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ShortSupplier handleThrowing(@Nonnull EShortSupplier handled,
																							 @Nonnull Function handler) throws X {
		return () -> {
			try {
				return handled.getAsShort();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing it
	 * explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ShortSupplier handleThrowing(@Nonnull EShortSupplier handled) throws E {
		return () -> {
			try {
				return handled.getAsShort();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled function with a
	 * provided handler.
	 *
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  LongSupplier handle(@Nonnull ELongSupplier handled,
															@Nonnull ToLongFunction handler) {
		return () -> {
			try {
				return handled.getAsLong();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.applyAsLong(e);
			}
		};
	}

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing a
	 * different exception.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  LongSupplier handleThrowing(@Nonnull ELongSupplier handled,
																							@Nonnull Function handler) throws X {
		return () -> {
			try {
				return handled.getAsLong();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles any exception types that may occur in the handled supplier by throwing it
	 * explicitly.
	 *
	 * @param 
	 *            The handled function's input type
	 * @param 
	 *            The handled function's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed supplier
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  LongSupplier handleThrowing(@Nonnull ELongSupplier handled) throws E {
		return () -> {
			try {
				return handled.getAsLong();
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	/*
	 * ================== UnaryOperators ==================
	 */

	/**
	 * Handles a generic exception type that may occur in the handled unary operator with
	 * a provided handler.
	 *
	 * @param 
	 *            The handled unary operator's input type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 */
	@Nonnull
	public static  UnaryOperator handle(@Nonnull EUnaryOperator handled,
																   @Nonnull BiFunction handler) {
		return t -> {
			try {
				return handled.applyChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				return handler.apply(e, t);
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled unary operator's input type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  UnaryOperator handleThrowing(@Nonnull EUnaryOperator handled,
																								@Nonnull Function handler) throws X {
		return t -> {
			try {
				return handled.applyChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled unary operator's input type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  UnaryOperator handleThrowing(@Nonnull EUnaryOperator handled) throws E {
		return t -> {
			try {
				return handled.applyChecked(t);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	// missing: handle EBooleanUnaryOperator, blocked by: missing boolean apply(T,
	// boolean)

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  BooleanUnaryOperator handleThrowing(@Nonnull EBooleanUnaryOperator handled,
																									@Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyCheckedAsBoolean(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  BooleanUnaryOperator handleThrowing(@Nonnull EBooleanUnaryOperator handled) throws E {
		return p -> {
			try {
				return handled.applyCheckedAsBoolean(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	// missing: handle EByteUnaryOperator, blocked by: missing byte apply(T, byte)

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ByteUnaryOperator handleThrowing(@Nonnull EByteUnaryOperator handled,
																								 @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyCheckedAsByte(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ByteUnaryOperator handleThrowing(@Nonnull EByteUnaryOperator handled) throws E {
		return p -> {
			try {
				return handled.applyCheckedAsByte(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	// missing: handle ECharUnaryOperator, blocked by: missing char apply(T, char)

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  CharUnaryOperator handleThrowing(@Nonnull ECharUnaryOperator handled,
																								 @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyCheckedAsChar(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  CharUnaryOperator handleThrowing(@Nonnull ECharUnaryOperator handled) throws E {
		return p -> {
			try {
				return handled.applyCheckedAsChar(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	// missing: handle EIntUnaryOperator, blocked by: missing int apply(T, int)

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  IntUnaryOperator handleThrowing(@Nonnull EIntUnaryOperator handled,
																								@Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyCheckedAsInt(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  IntUnaryOperator handleThrowing(@Nonnull EIntUnaryOperator handled) throws E {
		return p -> {
			try {
				return handled.applyCheckedAsInt(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	// missing: handle ELongUnaryOperator, blocked by: missing long apply(T, long)

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  LongUnaryOperator handleThrowing(@Nonnull ELongUnaryOperator handled,
																								 @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyCheckedAsLong(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  LongUnaryOperator handleThrowing(@Nonnull ELongUnaryOperator handled) throws E {
		return p -> {
			try {
				return handled.applyCheckedAsLong(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	// missing: handle EShortUnaryOperator, blocked by: missing short apply(T, short)

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing a different exception.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param 
	 *            The exception type to throw
	 * @param handled
	 *            The function that may throw an exception
	 * @param handler
	 *            The function handling exceptions
	 *
	 * @return An exception-proofed function
	 *
	 * @throws X
	 *             The exception returned by the handler
	 */
	@Nonnull
	@SuppressWarnings({ "null", "unused" })
	public static  ShortUnaryOperator handleThrowing(@Nonnull EShortUnaryOperator handled,
																								  @Nonnull Function handler) throws X {
		return p -> {
			try {
				return handled.applyCheckedAsShort(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(handler.apply(e));
			}
		};
	}

	/**
	 * Handles a generic exception type that may occur in the handled unary operator by
	 * throwing it explicitly.
	 *
	 * @param 
	 *            The handled unary operator's return type
	 * @param 
	 *            The handled unary operator's exception type
	 * @param handled
	 *            The function that may throw an exception
	 *
	 * @return An exception-proofed function
	 *
	 * @throws E
	 *             The checked exception
	 */
	@Nonnull
	@SuppressWarnings("unused")
	public static  ShortUnaryOperator handleThrowing(@Nonnull EShortUnaryOperator handled) throws E {
		return p -> {
			try {
				return handled.applyCheckedAsShort(p);
			} catch (Throwable e) { // NOSONAR can't catch generic exceptions
				throw asUnchecked(e);
			}
		};
	}

	private EHandle() {}

}