Additional methods

src/main/java/touk/pl/function/ThrowingBiFunction.java

@@ -2,10 +2,11 @@
 
 import java.util.Objects;
 
+@FunctionalInterface
 public interface ThrowingBiFunction<T1, T2, R, E extends Exception> {
     R apply(T1 arg1, T2 arg2) throws E;
 
-    default <V> ThrowingBiFunction<T1, T2, V, E> andThen(ThrowingFunction<? super R, ? extends V, E> after) {
+    default <V> ThrowingBiFunction<T1, T2, V, E> andThen(final ThrowingFunction<? super R, ? extends V, E> after) {
         Objects.requireNonNull(after);
 
         return (arg1, arg2) -> after.apply(apply(arg1, arg2));

src/main/java/touk/pl/function/ThrowingConsumer.java

@@ -0,0 +1,17 @@
+package touk.pl.function;
+
+import java.util.Objects;
+
+@FunctionalInterface
+public interface ThrowingConsumer<T, E extends Exception> {
+    void accept(T t) throws E;
+
+    default ThrowingConsumer<T, E> andThenConsume(final ThrowingConsumer<? super T, E> after) {
+        Objects.requireNonNull(after);
+
+        return t -> {
+            accept(t);
+            after.accept(t);
+        };
+    }
+}

src/main/java/touk/pl/function/ThrowingFunction.java

@@ -4,16 +4,21 @@
 import java.util.Optional;
 import java.util.function.Function;
 
+@FunctionalInterface
 public interface ThrowingFunction<T,R,E extends Exception> {
     R apply(T arg) throws E;
 
+    static <T, E extends Exception> ThrowingFunction<T, T, E> identity() {
+        return t -> t;
+    }
+
     default <V> ThrowingFunction<V, R, E> compose(final ThrowingFunction<? super V, ? extends T, E> before) {
         Objects.requireNonNull(before);
 
         return (V v) -> apply(before.apply(v));
     }
 
-    default <V> ThrowingFunction<T, V, E> andThen(ThrowingFunction<? super R, ? extends V, E> after) {
+    default <V> ThrowingFunction<T, V, E> andThen(final ThrowingFunction<? super R, ? extends V, E> after) {
         Objects.requireNonNull(after);
         return (T t) -> after.apply(apply(t));
     }

src/main/java/touk/pl/function/ThrowingPredicate.java

@@ -3,22 +3,23 @@
 import java.util.Objects;
 import java.util.Optional;
 
+@FunctionalInterface
 public interface ThrowingPredicate<T, E extends Exception> {
     boolean test(T t) throws E;
 
-    default ThrowingPredicate<T, E> and(ThrowingPredicate<? super T, E> other) {
+    default ThrowingPredicate<T, E> and(final ThrowingPredicate<? super T, E> other) {
         Objects.requireNonNull(other);
 
         return t -> test(t) && other.test(t);
     }
 
-    default ThrowingPredicate<T, E> or(ThrowingPredicate<? super T, E> other) {
+    default ThrowingPredicate<T, E> or(final ThrowingPredicate<? super T, E> other) {
         Objects.requireNonNull(other);
 
         return t -> test(t) || other.test(t);
     }
 
-    default ThrowingPredicate<T, E> xor(ThrowingPredicate<? super T, E> other) {
+    default ThrowingPredicate<T, E> xor(final ThrowingPredicate<? super T, E> other) {
         Objects.requireNonNull(other);
 
         return t -> test(t) ^ other.test(t);

src/main/java/touk/pl/function/ThrowingRunnable.java

@@ -0,0 +1,6 @@
+package touk.pl.function;
+
+@FunctionalInterface
+public interface ThrowingRunnable<E extends Exception> {
+    void run() throws E;
+}

src/main/java/touk/pl/function/ThrowingSupplier.java

@@ -0,0 +1,10 @@
+package touk.pl.function;
+
+@FunctionalInterface
+public interface ThrowingSupplier<T, E extends Exception> {
+    T get() throws E;
+
+    static <T, E extends Exception> ThrowingSupplier<T, E> empty() {
+        return () -> null;
+    }
+}

src/main/java/touk/pl/function/ThrowingUnaryOperator.java

@@ -0,0 +1,17 @@
+package touk.pl.function;
+
+@FunctionalInterface
+public interface ThrowingUnaryOperator<T, E extends Exception> extends ThrowingFunction<T, T, E> {
+
+    static <T, E extends Exception> ThrowingUnaryOperator<T, E> identity() {
+        return t -> t;
+    }
+
+    default ThrowingUnaryOperator<T, E> applyBefore(final ThrowingUnaryOperator<T, E> operator) {
+        return t -> operator.apply(apply(t));
+    }
+
+    default ThrowingUnaryOperator<T, E> applyAfter(final ThrowingUnaryOperator<T, E> operator) {
+        return t -> apply(operator.apply(t));
+    }
+}