Support name change for TryCatch

mperry · mperry · commit f86ba89bc0d3 · 2014-08-28T14:37:53.000+10:00
diff --git a/core/src/main/java/fj/F1Functions.java b/core/src/main/java/fj/F1Functions.java
@@ -840,7 +840,7 @@ 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, E extends Exception> F<A, Validation<E, B>> toF1(final TryCatch1<A, B, E> t) {
+    static public <A, B, E extends Exception> F<A, Validation<E, B>> toF1(final Try1<A, B, E> t) {
         return a -> {
             try {
                 return Validation.success(t.f(a));
diff --git a/core/src/main/java/fj/F2Functions.java b/core/src/main/java/fj/F2Functions.java
@@ -353,7 +353,7 @@ 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, E extends Exception> F2<A, B, Validation<E, C>> toF2(final TryCatch2<A, B, C, E> t) {
+    static public <A, B, C, E extends Exception> F2<A, B, Validation<E, C>> toF2(final Try2<A, B, C, E> t) {
         return (a, b) -> {
             try {
                 return Validation.success(t.f(a, b));
diff --git a/core/src/main/java/fj/F3Functions.java b/core/src/main/java/fj/F3Functions.java
@@ -16,7 +16,7 @@ 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, E extends Exception> F3<A, B, C, Validation<E, D>> toF3(final TryCatch3<A, B, C, D, E> t) {
+    static public <A, B, C, D, E extends Exception> F3<A, B, C, Validation<E, D>> toF3(final Try3<A, B, C, D, E> t) {
         return (a, b, c) -> {
             try {
                 return success(t.f(a, b, c));
diff --git a/core/src/main/java/fj/F4Functions.java b/core/src/main/java/fj/F4Functions.java
@@ -14,7 +14,7 @@ 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, Z extends Exception> F4<A, B, C, D, Validation<Z, E>> toF4(final TryCatch4<A, B, C, D, E, Z> t) {
+    static public <A, B, C, D, E, Z extends Exception> F4<A, B, C, D, Validation<Z, E>> toF4(final Try4<A, B, C, D, E, Z> t) {
         return (a, b, c, d) -> {
             try {
                 return Validation.success(t.f(a, b, c, d));
diff --git a/core/src/main/java/fj/F5Functions.java b/core/src/main/java/fj/F5Functions.java
@@ -13,7 +13,7 @@ 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, Z extends Exception> F5<A, B, C, D, E, Validation<Z, F>> toF5(final TryCatch5<A, B, C, D, E, F, Z> t) {
+    static public <A, B, C, D, E, F, Z extends Exception> F5<A, B, C, D, E, Validation<Z, F>> toF5(final Try5<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));
diff --git a/core/src/main/java/fj/F6Functions.java b/core/src/main/java/fj/F6Functions.java
@@ -13,7 +13,7 @@ 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, 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) {
+    static public <A, B, C, D, E, F, G, Z extends Exception> F6<A, B, C, D, E, F, Validation<Z, G>> toF6(final Try6<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));
diff --git a/core/src/main/java/fj/F7Functions.java b/core/src/main/java/fj/F7Functions.java
@@ -13,7 +13,7 @@ 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, 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) {
+    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 Try7<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));
diff --git a/core/src/main/java/fj/F8Functions.java b/core/src/main/java/fj/F8Functions.java
@@ -13,7 +13,7 @@ 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, 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) {
+    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 Try8<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));
diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
@@ -237,7 +237,7 @@ 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, E extends Exception> P1<Validation<E, A>> toP1(final TryCatch0<A, E> t) {
+    static public <A, E extends Exception> P1<Validation<E, A>> toP1(final Try0<A, E> t) {
         return P.lazy(u -> {
             try {
                 return Validation.success(t.f());
diff --git a/core/src/main/java/fj/Try.java b/core/src/main/java/fj/Try.java
@@ -11,43 +11,43 @@
  */
 public class Try {
 
-    public static <A, Z extends Exception> P1<Validation<Z, A>> f(TryCatch0<A, Z> t) {
+    public static <A, Z extends Exception> P1<Validation<Z, A>> f(Try0<A, Z> t) {
         return P1.toP1(t);
     }
 
-    public static <A, B, Z extends Exception> F<A, Validation<Z, B>> f(TryCatch1<A, B, Z> t) {
+    public static <A, B, Z extends Exception> F<A, Validation<Z, B>> f(Try1<A, B, Z> t) {
         return F1Functions.toF1(t);
     }
 
-    public static <A, B, C, Z extends Exception> F2<A, B, Validation<Z, C>> f(TryCatch2<A, B, C, Z> t) {
+    public static <A, B, C, Z extends Exception> F2<A, B, Validation<Z, C>> f(Try2<A, B, C, Z> t) {
         return F2Functions.toF2(t);
     }
 
-    public static <A, B, C, D, Z extends Exception> F3<A, B, C, Validation<Z, D>> f(TryCatch3<A, B, C, D, Z> t) {
+    public static <A, B, C, D, Z extends Exception> F3<A, B, C, Validation<Z, D>> f(Try3<A, B, C, D, Z> t) {
         return F3Functions.toF3(t);
     }
 
-    public static <A, B, C, D, E, Z extends Exception> F4<A, B, C, D, Validation<Z, E>> f(TryCatch4<A, B, C, D, E, Z> t) {
+    public static <A, B, C, D, E, Z extends Exception> F4<A, B, C, D, Validation<Z, E>> f(Try4<A, B, C, D, E, Z> t) {
         return F4Functions.toF4(t);
     }
 
-    public static <A, B, C, D, E, F$, Z extends Exception> F5<A, B, C, D, E, Validation<Z, F$>> f(TryCatch5<A, B, C, D, E, F$, Z> t) {
+    public static <A, B, C, D, E, F$, Z extends Exception> F5<A, B, C, D, E, Validation<Z, F$>> f(Try5<A, B, C, D, E, F$, Z> t) {
         return F5Functions.toF5(t);
     }
 
-    public static <A, B, C, D, E, F$, G, Z extends Exception> F6<A, B, C, D, E, F$, Validation<Z, G>> f(TryCatch6<A, B, C, D, E, F$, G, Z> t) {
+    public static <A, B, C, D, E, F$, G, Z extends Exception> F6<A, B, C, D, E, F$, Validation<Z, G>> f(Try6<A, B, C, D, E, F$, G, Z> t) {
         return F6Functions.toF6(t);
     }
 
-    public static <A, B, C, D, E, F$, G, H, Z extends Exception> F7<A, B, C, D, E, F$, G, Validation<Z, H>> f(TryCatch7<A, B, C, D, E, F$, G, H, Z> t) {
+    public static <A, B, C, D, E, F$, G, H, Z extends Exception> F7<A, B, C, D, E, F$, G, Validation<Z, H>> f(Try7<A, B, C, D, E, F$, G, H, Z> t) {
         return F7Functions.toF7(t);
     }
 
-    public static <A, B, C, D, E, F$, G, H, I, Z extends Exception> F8<A, B, C, D, E, F$, G, H, Validation<Z, I>> f(TryCatch8<A, B, C, D, E, F$, G, H, I, Z> t) {
+    public static <A, B, C, D, E, F$, G, H, I, Z extends Exception> F8<A, B, C, D, E, F$, G, H, Validation<Z, I>> f(Try8<A, B, C, D, E, F$, G, H, I, Z> t) {
         return F8Functions.toF8(t);
     }
 
-    public static <A> IO<A> io(TryCatch0<A, ? extends IOException> t) {
+    public static <A> IO<A> io(Try0<A, ? extends IOException> t) {
         return IOFunctions.io(t);
     }
 
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
@@ -30,7 +30,7 @@ public class IOFunctions {
   
   private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
 
-    public static <A> TryCatch0<A, IOException> toTry(IO<A> io) {
+    public static <A> Try0<A, IOException> toTry(IO<A> io) {
         return () -> io.run();
     }
 
@@ -42,7 +42,7 @@ public static <A> IO<A> io(P1<A> p) {
         return () -> p._1();
     }
 
-    public static <A> IO<A> io(TryCatch0<A, ? extends IOException> t) {
+    public static <A> IO<A> io(Try0<A, ? extends IOException> t) {
         return () -> t.f();
     }
 
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, E extends Exception> Supplier<Validation<E, A>> TryCatch0_Supplier(final TryCatch0<A, E> t) {
+    static public <A, E extends Exception> Supplier<Validation<E, A>> TryCatch0_Supplier(final Try0<A, E> t) {
         return Java8.<A, E>TryCatch0_Supplier().f(t);
     }
 
-    static public <A, E extends Exception> F<TryCatch0<A, E>, Supplier<Validation<E, A>>> TryCatch0_Supplier() {
+    static public <A, E extends Exception> F<Try0<A, E>, Supplier<Validation<E, A>>> TryCatch0_Supplier() {
         return t -> () -> P1.toP1(t)._1();
     }
 
-    static public <A, B, E extends Exception> Function<A, Validation<E, B>> TryCatch1_Function(final TryCatch1<A, B, E> t) {
+    static public <A, B, E extends Exception> Function<A, Validation<E, B>> TryCatch1_Function(final Try1<A, B, E> t) {
         return Java8.<A, B, E>TryCatch1_Function().f(t);
     }
 
-    static public <A, B, E extends Exception> F<TryCatch1<A, B, E>, Function<A, Validation<E, B>>> TryCatch1_Function() {
+    static public <A, B, E extends Exception> F<Try1<A, B, E>, Function<A, Validation<E, B>>> TryCatch1_Function() {
         return t -> a -> F1Functions.toF1(t).f(a);
     }
 
-    static public <A, B, C, E extends Exception> BiFunction<A, B, Validation<E, C>> TryCatch2_BiFunction(final TryCatch2<A, B, C, E> t) {
+    static public <A, B, C, E extends Exception> BiFunction<A, B, Validation<E, C>> TryCatch2_BiFunction(final Try2<A, B, C, E> t) {
         return Java8.<A, B, C, E>TryCatch2_BiFunction().f(t);
     }
 
-    static public <A, B, C, E extends Exception> F<TryCatch2<A, B, C, E>, BiFunction<A, B, Validation<E, C>>> TryCatch2_BiFunction() {
+    static public <A, B, C, E extends Exception> F<Try2<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
`@@ -11,43 +11,43 @@`
`11`	`11`	`*/`
`12`	`12`	`public class Try {`
`13`	`13`
`14`		`- public static <A, Z extends Exception> P1<Validation<Z, A>> f(TryCatch0<A, Z> t) {`
	`14`	`+ public static <A, Z extends Exception> P1<Validation<Z, A>> f(Try0<A, Z> t) {`
`15`	`15`	`return P1.toP1(t);`
`16`	`16`	`}`
`17`	`17`
`18`		`- public static <A, B, Z extends Exception> F<A, Validation<Z, B>> f(TryCatch1<A, B, Z> t) {`
	`18`	`+ public static <A, B, Z extends Exception> F<A, Validation<Z, B>> f(Try1<A, B, Z> t) {`
`19`	`19`	`return F1Functions.toF1(t);`
`20`	`20`	`}`
`21`	`21`
`22`		`- public static <A, B, C, Z extends Exception> F2<A, B, Validation<Z, C>> f(TryCatch2<A, B, C, Z> t) {`
	`22`	`+ public static <A, B, C, Z extends Exception> F2<A, B, Validation<Z, C>> f(Try2<A, B, C, Z> t) {`
`23`	`23`	`return F2Functions.toF2(t);`
`24`	`24`	`}`
`25`	`25`
`26`		`- public static <A, B, C, D, Z extends Exception> F3<A, B, C, Validation<Z, D>> f(TryCatch3<A, B, C, D, Z> t) {`
	`26`	`+ public static <A, B, C, D, Z extends Exception> F3<A, B, C, Validation<Z, D>> f(Try3<A, B, C, D, Z> t) {`
`27`	`27`	`return F3Functions.toF3(t);`
`28`	`28`	`}`
`29`	`29`
`30`		`- public static <A, B, C, D, E, Z extends Exception> F4<A, B, C, D, Validation<Z, E>> f(TryCatch4<A, B, C, D, E, Z> t) {`
	`30`	`+ public static <A, B, C, D, E, Z extends Exception> F4<A, B, C, D, Validation<Z, E>> f(Try4<A, B, C, D, E, Z> t) {`
`31`	`31`	`return F4Functions.toF4(t);`
`32`	`32`	`}`
`33`	`33`
`34`		`- public static <A, B, C, D, E, F$, Z extends Exception> F5<A, B, C, D, E, Validation<Z, F$>> f(TryCatch5<A, B, C, D, E, F$, Z> t) {`
	`34`	`+ public static <A, B, C, D, E, F$, Z extends Exception> F5<A, B, C, D, E, Validation<Z, F$>> f(Try5<A, B, C, D, E, F$, Z> t) {`
`35`	`35`	`return F5Functions.toF5(t);`
`36`	`36`	`}`
`37`	`37`
`38`		`- public static <A, B, C, D, E, F$, G, Z extends Exception> F6<A, B, C, D, E, F$, Validation<Z, G>> f(TryCatch6<A, B, C, D, E, F$, G, Z> t) {`
	`38`	`+ public static <A, B, C, D, E, F$, G, Z extends Exception> F6<A, B, C, D, E, F$, Validation<Z, G>> f(Try6<A, B, C, D, E, F$, G, Z> t) {`
`39`	`39`	`return F6Functions.toF6(t);`
`40`	`40`	`}`
`41`	`41`
`42`		`- public static <A, B, C, D, E, F$, G, H, Z extends Exception> F7<A, B, C, D, E, F$, G, Validation<Z, H>> f(TryCatch7<A, B, C, D, E, F$, G, H, Z> t) {`
	`42`	`+ public static <A, B, C, D, E, F$, G, H, Z extends Exception> F7<A, B, C, D, E, F$, G, Validation<Z, H>> f(Try7<A, B, C, D, E, F$, G, H, Z> t) {`
`43`	`43`	`return F7Functions.toF7(t);`
`44`	`44`	`}`
`45`	`45`
`46`		`- public static <A, B, C, D, E, F$, G, H, I, Z extends Exception> F8<A, B, C, D, E, F$, G, H, Validation<Z, I>> f(TryCatch8<A, B, C, D, E, F$, G, H, I, Z> t) {`
	`46`	`+ public static <A, B, C, D, E, F$, G, H, I, Z extends Exception> F8<A, B, C, D, E, F$, G, H, Validation<Z, I>> f(Try8<A, B, C, D, E, F$, G, H, I, Z> t) {`
`47`	`47`	`return F8Functions.toF8(t);`
`48`	`48`	`}`
`49`	`49`
`50`		`- public static <A> IO<A> io(TryCatch0<A, ? extends IOException> t) {`
	`50`	`+ public static <A> IO<A> io(Try0<A, ? extends IOException> t) {`
`51`	`51`	`return IOFunctions.io(t);`
`52`	`52`	`}`
`53`	`53`