Cleaned up ThrowingCallable again. Callable do trhow already.

Author: mihxil

mihxil-functional/src/main/java/org/meeuw/functional/Functions.java

@@ -178,11 +178,29 @@ public R call() throws E {
      * @return a new callable, which will use the given function and argument for its implementation
      * @since 0.14
      */
-    public static <A1, R, E extends Exception> Callable<R> withArg1(ThrowingFunction<A1, R, E> function) {
-        return new CallableWrapper<ThrowingFunction<A1, R, E>, R>(function, null) {
+    public static <A1, R, E extends Exception> Callable<R> withNull(ThrowingFunction<A1, R, E> function) {
+        return withArg1(function, null);
+    }
+
+
+    /**
+     * Giving a {@link ThrowingFunction function}, morphs it into a {@link Callable} that ignores its argument and just calls the function with {@code null}.
+     *
+     * @param <R> the return value of the function, and of the resulting {@link Callable}
+     * @param <E> the exception type that the function (and the callable) can throw
+     * @param callable the function on which to base the new {@code Callable} on
+     * @return a new function, which will use the given call its implementation. The argument of the function will be ignored, all calls just call the {@code Callable}.
+     * @since 0.14
+     */
+    public static <R, E extends Exception > ThrowingFunction<Void, R, E> ignoreArg1(Callable<R> callable) {
+        return new ThrowingMonoWrapper<Callable<R>, Void, R,  E>(callable, null, "function") {
             @Override
-            public R call() throws E {
-                return wrapped.applyWithException(null);
+            public R applyWithException(Void o) throws E {
+                try {
+                    return callable.call();
+                } catch (Exception e) {
+                    return Sneaky.sneakyThrow(e);
+                }
             }
         };
     }
@@ -522,6 +540,20 @@ public MonoWrapper(W wrapped, Object value, String why) {
         }
     }
 
+
+
+    protected static abstract  class ThrowingMonoWrapper<W, X, R, E extends Exception>  extends ValueWrapper<W> implements ThrowingFunction<X, R, E> {
+        public ThrowingMonoWrapper(W wrapped, Object value, String why) {
+            super(wrapped, value, why);
+        }
+    }
+
+
+    /**
+     * A wrapper that is  {@link Callable}
+     * @param <W>
+     * @param <X>
+     */
     protected static abstract  class CallableWrapper<W, X>  extends Wrapper<W> implements Callable<X> {
         public CallableWrapper(W wrapped, String why) {
             super(wrapped, why);

mihxil-functional/src/main/java/org/meeuw/functional/ThrowAnyCallable.java

@@ -8,6 +8,7 @@
 /**
  * An extension of {@link Function} that can throw exceptions too.
  * @since 1.13
+ * @param <E> the type of exception that can be thrown
  */
 @FunctionalInterface
 public interface ThrowingFunction<A, R, E extends Exception> extends Function<A, R> {

mihxil-functional/src/main/java/org/meeuw/functional/ThrowingCallable.java

@@ -1,5 +1,9 @@
 package org.meeuw.functional;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.*;
 
 import org.junit.jupiter.api.Test;
@@ -12,6 +16,7 @@
 /**
  * @author Michiel Meeuwissen
  */
+@SuppressWarnings({"ConstantValue", "EqualsBetweenInconvertibleTypes"})
 class FunctionsTest {
 
     @Test
@@ -80,17 +85,32 @@ void quadriAlways() {
 
 
 
+
+
     @Test
     void monoWithArg1() {
         assertThat(withArg1(mono, 1.0f).get()).isEqualTo(("1.0"));
     }
 
     @Test
-    void tmonoWithArg1() throws Exception {
-        assertThat(withArg1(tmono, 1.0f).call()).isEqualTo(("1.0"));
+    void tmonoWithNull() throws Exception {
+        List<String> list = new ArrayList<>();
+        AtomicInteger counter = new AtomicInteger();
+        Callable<Integer> callable = () -> {
+            int result =  counter.incrementAndGet();
+            if (result % 3 == 0) {
+                throw new IllegalArgumentException();
+            }
+            return result;
+        };
+        Callable<Integer> wrapped = withNull(ignoreArg1(callable));
+
+        assertThat(wrapped.call()).isEqualTo(1);
+        assertThat(wrapped.call()).isEqualTo(2);
+        assertThatThrownBy(wrapped::call).isInstanceOf(IllegalArgumentException.class);
+
 
-        assertThatThrownBy(() ->
-            withArg1(tmono, 0.0f).call()).isInstanceOf(IllegalArgumentException.class);
+        assertThat(wrapped.toString()).endsWith("(function)(with  arg1 null)");
 
     }