Made TryCatchN family take a generic exception type parameter

mperry · mperry · commit 1b63285fafdd · 2014-07-03T15:49:36.000+10:00
diff --git a/core/src/main/java/fj/F1Functions.java b/core/src/main/java/fj/F1Functions.java
@@ -830,12 +830,12 @@ static public <A, B> ArrayList<B> mapJ(final F<A, B> f, final ArrayList<A> as) {
      * @param t A TryCatch1 to promote
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
-    static public <A, B> F<A, Validation<Exception, B>> toF1(final TryCatch1<A, B> t) {
+    static public <A, B, E extends Exception> F<A, Validation<E, B>> toF1(final TryCatch1<A, B, E> t) {
         return a -> {
             try {
                 return Validation.success(t.f(a));
             } catch (Exception e) {
-                return Validation.fail(e);
+                return Validation.fail((E) e);
             }
         };
     }
diff --git a/core/src/main/java/fj/F2Functions.java b/core/src/main/java/fj/F2Functions.java
@@ -353,12 +353,12 @@ public P3<Stream<Tree<C>>, C, Stream<Tree<C>>> f(final P3<Stream<Tree<A>>, A, St
      * @param t A TryCatch2 to promote
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
-    static public <A, B, C> F2<A, B, Validation<Exception, C>> toF2(final TryCatch2<A, B, C> t) {
+    static public <A, B, C, E extends Exception> F2<A, B, Validation<E, C>> toF2(final TryCatch2<A, B, C, E> t) {
         return (a, b) -> {
             try {
                 return Validation.success(t.f(a, b));
             } catch (Exception e) {
-                return Validation.fail(e);
+                return Validation.fail((E) e);
             }
         };
     }
diff --git a/core/src/main/java/fj/F3Functions.java b/core/src/main/java/fj/F3Functions.java
@@ -16,12 +16,12 @@ public class F3Functions {
      * @param t A TryCatch3 to promote
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
-    static public <A, B, C, D> F3<A, B, C, Validation<Exception, D>> toF3(final TryCatch3<A, B, C, D> t) {
+    static public <A, B, C, D, E extends Exception> F3<A, B, C, Validation<E, D>> toF3(final TryCatch3<A, B, C, D, E> t) {
         return (a, b, c) -> {
             try {
                 return success(t.f(a, b, c));
             } catch (Exception e) {
-                return fail(e);
+                return fail((E) e);
             }
         };
     }
diff --git a/core/src/main/java/fj/F4Functions.java b/core/src/main/java/fj/F4Functions.java
@@ -14,12 +14,12 @@ public class F4Functions {
      * @param t A TryCatch4 to promote
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
-    static public <A, B, C, D, E> F4<A, B, C, D, Validation<Exception, E>> toF4(final TryCatch4<A, B, C, D, E> t) {
+    static public <A, B, C, D, E, Z extends Exception> F4<A, B, C, D, Validation<Z, E>> toF4(final TryCatch4<A, B, C, D, E, Z> t) {
         return (a, b, c, d) -> {
             try {
                 return Validation.success(t.f(a, b, c, d));
             } catch (Exception ex) {
-                return Validation.fail(ex);
+                return Validation.fail((Z) ex);
             }
         };
     }
diff --git a/core/src/main/java/fj/F5Functions.java b/core/src/main/java/fj/F5Functions.java
@@ -13,12 +13,12 @@ public class F5Functions {
      * @param t A TryCatch5 to promote
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
-    static public <A, B, C, D, E, F> F5<A, B, C, D, E, Validation<Exception, F>> toF5(final TryCatch5<A, B, C, D, E, F> t) {
+    static public <A, B, C, D, E, F, Z extends Exception> F5<A, B, C, D, E, Validation<Z, F>> toF5(final TryCatch5<A, B, C, D, E, F, Z> t) {
         return (a, b, c, d, e) -> {
             try {
                 return Validation.success(t.f(a, b, c, d, e));
             } catch (Exception ex) {
-                return Validation.fail(ex);
+                return Validation.fail((Z) ex);
             }
         };
     }
diff --git a/core/src/main/java/fj/F6Functions.java b/core/src/main/java/fj/F6Functions.java
@@ -13,12 +13,12 @@ public class F6Functions {
      * @param t A TryCatch6 to promote
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
-    static public <A, B, C, D, E, F, G> F6<A, B, C, D, E, F, Validation<Exception, G>> toF6(final TryCatch6<A, B, C, D, E, F, G> t) {
+    static public <A, B, C, D, E, F, G, Z extends Exception> F6<A, B, C, D, E, F, Validation<Z, G>> toF6(final TryCatch6<A, B, C, D, E, F, G, Z> t) {
         return (a, b, c, d, e, f) -> {
             try {
                 return Validation.success(t.f(a, b, c, d, e, f));
             } catch (Exception ex) {
-                return Validation.fail(ex);
+                return Validation.fail((Z) ex);
             }
         };
     }
diff --git a/core/src/main/java/fj/F7Functions.java b/core/src/main/java/fj/F7Functions.java
@@ -13,12 +13,12 @@ public class F7Functions {
      * @param t A TryCatch7 to promote
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
-    static public <A, B, C, D, E, F, G, H> F7<A, B, C, D, E, F, G, Validation<Exception, H>> toF7(final TryCatch7<A, B, C, D, E, F, G, H> t) {
+    static public <A, B, C, D, E, F, G, H, Z extends Exception> F7<A, B, C, D, E, F, G, Validation<Z, H>> toF7(final TryCatch7<A, B, C, D, E, F, G, H, Z> t) {
         return (a, b, c, d, e, f, g) -> {
             try {
                 return Validation.success(t.f(a, b, c, d, e, f, g));
             } catch (Exception ex) {
-                return Validation.fail(ex);
+                return Validation.fail((Z) ex);
             }
         };
     }
diff --git a/core/src/main/java/fj/F8Functions.java b/core/src/main/java/fj/F8Functions.java
@@ -13,12 +13,12 @@ public class F8Functions {
      * @param t A TryCatch8 to promote
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
-    static public <A, B, C, D, E, F, G, H, I> F8<A, B, C, D, E, F, G, H, Validation<Exception, I>> toF8(final TryCatch8<A, B, C, D, E, F, G, H, I> t) {
+    static public <A, B, C, D, E, F, G, H, I, Z extends Exception> F8<A, B, C, D, E, F, G, H, Validation<Z, I>> toF8(final TryCatch8<A, B, C, D, E, F, G, H, I, Z> t) {
         return (a, b, c, d, e, f, g, h) -> {
             try {
                 return Validation.success(t.f(a, b, c, d, e, f, g, h));
             } catch (Exception ex) {
-                return Validation.fail(ex);
+                return Validation.fail((Z) ex);
             }
         };
     }
diff --git a/core/src/main/java/fj/P1Functions.java b/core/src/main/java/fj/P1Functions.java
@@ -224,12 +224,12 @@ public A f(final B b) {
      * @param t A TryCatch0 to promote
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
-    static public <A> P1<Validation<Exception, A>> toP1(final TryCatch0<A> t) {
+    static public <A, E extends Exception> P1<Validation<E, A>> toP1(final TryCatch0<A, E> t) {
         return () -> {
             try {
                 return Validation.success(t.f());
             } catch (Exception e) {
-                return Validation.fail(e);
+                return Validation.fail((E) e);
             }
         };
     }
diff --git a/core/src/main/java/fj/TryCatch0.java b/core/src/main/java/fj/TryCatch0.java
@@ -9,8 +9,8 @@
  * @version %build.number%
  */
 
-public interface TryCatch0<A> {
+public interface TryCatch0<A, E extends Exception> {
 
-    A f() throws Exception;
+    A f() throws E;
 
 }
diff --git a/core/src/main/java/fj/TryCatch1.java b/core/src/main/java/fj/TryCatch1.java
@@ -9,8 +9,8 @@
  * @version %build.number%
  */
 
-public interface TryCatch1<A, B> {
+public interface TryCatch1<A, B, E extends Exception> {
 
-    B f(A a) throws Exception;
+    B f(A a) throws E;
 
 }
diff --git a/core/src/main/java/fj/TryCatch2.java b/core/src/main/java/fj/TryCatch2.java
@@ -9,8 +9,8 @@
  * @version %build.number%
  */
 
-public interface TryCatch2<A, B, C> {
+public interface TryCatch2<A, B, C, E extends Exception> {
 
-    C f(A a, B b) throws Exception;
+    C f(A a, B b) throws E;
 
 }
diff --git a/core/src/main/java/fj/TryCatch3.java b/core/src/main/java/fj/TryCatch3.java
@@ -9,8 +9,8 @@
  * @version %build.number%
  */
 
-public interface TryCatch3<A, B, C, D> {
+public interface TryCatch3<A, B, C, D, E extends Exception> {
 
-    D f(A a, B b, C c) throws Exception;
+    D f(A a, B b, C c) throws E;
 
 }
diff --git a/core/src/main/java/fj/TryCatch4.java b/core/src/main/java/fj/TryCatch4.java
@@ -9,8 +9,8 @@
  * @version %build.number%
  */
 
-public interface TryCatch4<A, B, C, D, E> {
+public interface TryCatch4<A, B, C, D, E, Z extends Exception> {
 
-    E f(A a, B b, C c, D d) throws Exception;
+    E f(A a, B b, C c, D d) throws Z;
 
 }
diff --git a/core/src/main/java/fj/TryCatch5.java b/core/src/main/java/fj/TryCatch5.java
@@ -9,8 +9,8 @@
  * @version %build.number%
  */
 
-public interface TryCatch5<A, B, C, D, E, F> {
+public interface TryCatch5<A, B, C, D, E, F, Z extends Exception> {
 
-    F f(A a, B b, C c, D d, E e) throws Exception;
+    F f(A a, B b, C c, D d, E e) throws Z;
 
 }
diff --git a/core/src/main/java/fj/TryCatch6.java b/core/src/main/java/fj/TryCatch6.java
@@ -9,8 +9,8 @@
  * @version %build.number%
  */
 
-public interface TryCatch6<A, B, C, D, E, F, G> {
+public interface TryCatch6<A, B, C, D, E, F, G, Z extends Exception> {
 
-    G f(A a, B b, C c, D d, E e, F f) throws Exception;
+    G f(A a, B b, C c, D d, E e, F f) throws Z;
 
 }
diff --git a/core/src/main/java/fj/TryCatch7.java b/core/src/main/java/fj/TryCatch7.java
@@ -10,8 +10,8 @@
  * @version %build.number%
  */
 
-public interface TryCatch7<A, B, C, D, E, F, G, H> {
+public interface TryCatch7<A, B, C, D, E, F, G, H, Z extends Exception> {
 
-    H f(A a, B b, C c, D d, E e, F f, G g) throws Exception;
+    H f(A a, B b, C c, D d, E e, F f, G g) throws Z;
 
 }
diff --git a/core/src/main/java/fj/TryCatch8.java b/core/src/main/java/fj/TryCatch8.java
@@ -9,8 +9,8 @@
  * @version %build.number%
  */
 
-public interface TryCatch8<A, B, C, D, E, F, G, H, I> {
+public interface TryCatch8<A, B, C, D, E, F, G, H, I, Z extends Exception> {
 
-    I f(A a, B b, C c, D d, E e, F f, G g, H h) throws Exception;
+    I f(A a, B b, C c, D d, E e, F f, G g, H h) throws Z;
 
 }
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
@@ -26,7 +26,7 @@
  * @author Martin Grotzke
  *
  */
-public abstract class IOFunctions {
+public class IOFunctions {
   
   private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
 
@@ -334,5 +334,8 @@ public static <A> IO<A> join(IO<IO<A>> io1) {
 		return bind(io1, io2 -> io2);
 	}
 
+	public static <A> SafeIO<IOException, A> toSafeIO(IO<A> io) {
+		return () -> P1Functions.toP1(() -> io.run())._1();
+	}
 
 }
diff --git a/java8/src/main/java/fj/data/Java8.java b/java8/src/main/java/fj/data/Java8.java
@@ -64,27 +64,27 @@ public static <A, B, C> F<F2<A, B, C>, BiFunction<A, B, C>> F2_BiFunction() {
         return f -> (a, b) -> f.f(a, b);
     }
 
-    static public <A> Supplier<Validation<Exception, A>> TryCatch0_Supplier(final TryCatch0<A> t) {
-        return Java8.<A>TryCatch0_Supplier().f(t);
+    static public <A, E extends Exception> Supplier<Validation<E, A>> TryCatch0_Supplier(final TryCatch0<A, E> t) {
+        return Java8.<A, E>TryCatch0_Supplier().f(t);
     }
 
-    static public <A> F<TryCatch0<A>, Supplier<Validation<Exception, A>>> TryCatch0_Supplier() {
+    static public <A, E extends Exception> F<TryCatch0<A, E>, Supplier<Validation<E, A>>> TryCatch0_Supplier() {
         return t -> () -> P1Functions.toP1(t)._1();
     }
 
-    static public <A, B> Function<A, Validation<Exception, B>> TryCatch1_Function(final TryCatch1<A, B> t) {
-        return Java8.<A, B>TryCatch1_Function().f(t);
+    static public <A, B, E extends Exception> Function<A, Validation<E, B>> TryCatch1_Function(final TryCatch1<A, B, E> t) {
+        return Java8.<A, B, E>TryCatch1_Function().f(t);
     }
 
-    static public <A, B> F<TryCatch1<A, B>, Function<A, Validation<Exception, B>>> TryCatch1_Function() {
+    static public <A, B, E extends Exception> F<TryCatch1<A, B, E>, Function<A, Validation<E, B>>> TryCatch1_Function() {
         return t -> a -> F1Functions.toF1(t).f(a);
     }
 
-    static public <A, B, C> BiFunction<A, B, Validation<Exception, C>> TryCatch2_BiFunction(final TryCatch2<A, B, C> t) {
-        return Java8.<A, B, C>TryCatch2_BiFunction().f(t);
+    static public <A, B, C, E extends Exception> BiFunction<A, B, Validation<E, C>> TryCatch2_BiFunction(final TryCatch2<A, B, C, E> t) {
+        return Java8.<A, B, C, E>TryCatch2_BiFunction().f(t);
     }
 
-    static public <A, B, C> F<TryCatch2<A, B, C>, BiFunction<A, B, Validation<Exception, C>>> TryCatch2_BiFunction() {
+    static public <A, B, C, E extends Exception> F<TryCatch2<A, B, C, E>, BiFunction<A, B, Validation<E, C>>> TryCatch2_BiFunction() {
         return t -> (a, b) -> F2Functions.toF2(t).f(a, b);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,8 @@`
`9`	`9`	`* @version %build.number%`
`10`	`10`	`*/`
`11`	`11`
`12`		`-public interface TryCatch0<A> {`
	`12`	`+public interface TryCatch0<A, E extends Exception> {`
`13`	`13`
`14`		`- A f() throws Exception;`
	`14`	`+ A f() throws E;`
`15`	`15`
`16`	`16`	`}`