Better parameter naming for CheckedFunction* (#3019)

Author: pivovarit

vavr/generator/Generator.scala

@@ -1586,7 +1586,6 @@ def generateMainClasses(): Unit = {
                * @return a function that applies arguments to the given {@code partialFunction} and returns {@code Some(result)}
                *         if the function is defined for the given arguments, and {@code None} otherwise.
                */
-              @SuppressWarnings("RedundantTypeArguments")
               static $fullGenerics ${im.getType(s"io.vavr.Function$i")}$genericsOptionReturnType lift($fullGenericsType partialFunction) {
                   ${
                     val func = "partialFunction"
@@ -1893,7 +1892,7 @@ def generateMainClasses(): Unit = {
               """)}
 
               ${(1 to i).gen(j => {
-                val fName = s"before$j"
+                val fName = s"before"
                 val fGeneric = "S"
                 val applicationArgs = (1 to i).gen(k => if (k == j) s"$fGeneric ${fGeneric.toLowerCase}" else s"T$k t$k")(", ")
                 val generics = (1 to i).gen(k => if (k == j) "S" else s"T$k")(", ")

vavr/src-gen/main/java/io/vavr/CheckedFunction0.java

@@ -104,7 +104,6 @@ static <R> CheckedFunction0<R> of(CheckedFunction0<R> methodReference) {
      * @return a function that applies arguments to the given {@code partialFunction} and returns {@code Some(result)}
      *         if the function is defined for the given arguments, and {@code None} otherwise.
      */
-    @SuppressWarnings("RedundantTypeArguments")
     static <R> Function0<Option<R>> lift(CheckedFunction0<? extends R> partialFunction) {
         return () -> Try.<R>of(partialFunction::apply).toOption();
     }

vavr/src-gen/main/java/io/vavr/CheckedFunction1.java

@@ -109,7 +109,6 @@ static <T1, R> CheckedFunction1<T1, R> of(CheckedFunction1<T1, R> methodReferenc
      * @return a function that applies arguments to the given {@code partialFunction} and returns {@code Some(result)}
      *         if the function is defined for the given arguments, and {@code None} otherwise.
      */
-    @SuppressWarnings("RedundantTypeArguments")
     static <T1, R> Function1<T1, Option<R>> lift(CheckedFunction1<? super T1, ? extends R> partialFunction) {
         return t1 -> Try.<R>of(() -> partialFunction.apply(t1)).toOption();
     }
@@ -300,17 +299,17 @@ default <V> CheckedFunction1<V, R> compose(CheckedFunction1<? super V, ? extends
     }
 
     /**
-     * Returns a composed function that first applies the {@linkplain Function} {@code before1} to the
+     * Returns a composed function that first applies the {@linkplain Function} {@code before} to the
      * 1st argument and then applies this CheckedFunction1 to the result.
      *
-     * @param <S> argument type of before1
-     * @param before1 the function applied before this
-     * @return a function composed of before1 and this
-     * @throws NullPointerException if before1 is null
+     * @param <S> argument type of before
+     * @param before the function applied before this
+     * @return a function composed of before and this
+     * @throws NullPointerException if before is null
      */
-    default <S> CheckedFunction1<S, R> compose1(Function1<? super S, ? extends T1> before1) {
-        Objects.requireNonNull(before1, "before1 is null");
-        return (S s) -> apply(before1.apply(s));
+    default <S> CheckedFunction1<S, R> compose1(Function1<? super S, ? extends T1> before) {
+        Objects.requireNonNull(before, "before is null");
+        return (S s) -> apply(before.apply(s));
     }
 }
 

vavr/src-gen/main/java/io/vavr/CheckedFunction2.java

@@ -114,7 +114,6 @@ static <T1, T2, R> CheckedFunction2<T1, T2, R> of(CheckedFunction2<T1, T2, R> me
      * @return a function that applies arguments to the given {@code partialFunction} and returns {@code Some(result)}
      *         if the function is defined for the given arguments, and {@code None} otherwise.
      */
-    @SuppressWarnings("RedundantTypeArguments")
     static <T1, T2, R> Function2<T1, T2, Option<R>> lift(CheckedFunction2<? super T1, ? super T2, ? extends R> partialFunction) {
         return (t1, t2) -> Try.<R>of(() -> partialFunction.apply(t1, t2)).toOption();
     }
@@ -295,31 +294,31 @@ default <V> CheckedFunction2<T1, T2, V> andThen(CheckedFunction1<? super R, ? ex
     }
 
     /**
-     * Returns a composed function that first applies the {@linkplain Function} {@code before1} to the
+     * Returns a composed function that first applies the {@linkplain Function} {@code before} to the
      * 1st argument and then applies this CheckedFunction2 to the result and the other argument.
      *
-     * @param <S> argument type of before1
-     * @param before1 the function applied before this
-     * @return a function composed of before1 and this
-     * @throws NullPointerException if before1 is null
+     * @param <S> argument type of before
+     * @param before the function applied before this
+     * @return a function composed of before and this
+     * @throws NullPointerException if before is null
      */
-    default <S> CheckedFunction2<S, T2, R> compose1(Function1<? super S, ? extends T1> before1) {
-        Objects.requireNonNull(before1, "before1 is null");
-        return (S s, T2 t2) -> apply(before1.apply(s), t2);
+    default <S> CheckedFunction2<S, T2, R> compose1(Function1<? super S, ? extends T1> before) {
+        Objects.requireNonNull(before, "before is null");
+        return (S s, T2 t2) -> apply(before.apply(s), t2);
     }
 
     /**
-     * Returns a composed function that first applies the {@linkplain Function} {@code before2} to the
+     * Returns a composed function that first applies the {@linkplain Function} {@code before} to the
      * 2nd argument and then applies this CheckedFunction2 to the result and the other argument.
      *
-     * @param <S> argument type of before2
-     * @param before2 the function applied before this
-     * @return a function composed of before2 and this
-     * @throws NullPointerException if before2 is null
+     * @param <S> argument type of before
+     * @param before the function applied before this
+     * @return a function composed of before and this
+     * @throws NullPointerException if before is null
      */
-    default <S> CheckedFunction2<T1, S, R> compose2(Function1<? super S, ? extends T2> before2) {
-        Objects.requireNonNull(before2, "before2 is null");
-        return (T1 t1, S s) -> apply(t1, before2.apply(s));
+    default <S> CheckedFunction2<T1, S, R> compose2(Function1<? super S, ? extends T2> before) {
+        Objects.requireNonNull(before, "before is null");
+        return (T1 t1, S s) -> apply(t1, before.apply(s));
     }
 }
 

vavr/src-gen/main/java/io/vavr/CheckedFunction3.java

@@ -117,7 +117,6 @@ static <T1, T2, T3, R> CheckedFunction3<T1, T2, T3, R> of(CheckedFunction3<T1, T
      * @return a function that applies arguments to the given {@code partialFunction} and returns {@code Some(result)}
      *         if the function is defined for the given arguments, and {@code None} otherwise.
      */
-    @SuppressWarnings("RedundantTypeArguments")
     static <T1, T2, T3, R> Function3<T1, T2, T3, Option<R>> lift(CheckedFunction3<? super T1, ? super T2, ? super T3, ? extends R> partialFunction) {
         return (t1, t2, t3) -> Try.<R>of(() -> partialFunction.apply(t1, t2, t3)).toOption();
     }
@@ -312,45 +311,45 @@ default <V> CheckedFunction3<T1, T2, T3, V> andThen(CheckedFunction1<? super R,
     }
 
     /**
-     * Returns a composed function that first applies the {@linkplain Function} {@code before1} to the
+     * Returns a composed function that first applies the {@linkplain Function} {@code before} to the
      * 1st argument and then applies this CheckedFunction3 to the result and the other arguments.
      *
-     * @param <S> argument type of before1
-     * @param before1 the function applied before this
-     * @return a function composed of before1 and this
-     * @throws NullPointerException if before1 is null
+     * @param <S> argument type of before
+     * @param before the function applied before this
+     * @return a function composed of before and this
+     * @throws NullPointerException if before is null
      */
-    default <S> CheckedFunction3<S, T2, T3, R> compose1(Function1<? super S, ? extends T1> before1) {
-        Objects.requireNonNull(before1, "before1 is null");
-        return (S s, T2 t2, T3 t3) -> apply(before1.apply(s), t2, t3);
+    default <S> CheckedFunction3<S, T2, T3, R> compose1(Function1<? super S, ? extends T1> before) {
+        Objects.requireNonNull(before, "before is null");
+        return (S s, T2 t2, T3 t3) -> apply(before.apply(s), t2, t3);
     }
 
     /**
-     * Returns a composed function that first applies the {@linkplain Function} {@code before2} to the
+     * Returns a composed function that first applies the {@linkplain Function} {@code before} to the
      * 2nd argument and then applies this CheckedFunction3 to the result and the other arguments.
      *
-     * @param <S> argument type of before2
-     * @param before2 the function applied before this
-     * @return a function composed of before2 and this
-     * @throws NullPointerException if before2 is null
+     * @param <S> argument type of before
+     * @param before the function applied before this
+     * @return a function composed of before and this
+     * @throws NullPointerException if before is null
      */
-    default <S> CheckedFunction3<T1, S, T3, R> compose2(Function1<? super S, ? extends T2> before2) {
-        Objects.requireNonNull(before2, "before2 is null");
-        return (T1 t1, S s, T3 t3) -> apply(t1, before2.apply(s), t3);
+    default <S> CheckedFunction3<T1, S, T3, R> compose2(Function1<? super S, ? extends T2> before) {
+        Objects.requireNonNull(before, "before is null");
+        return (T1 t1, S s, T3 t3) -> apply(t1, before.apply(s), t3);
     }
 
     /**
-     * Returns a composed function that first applies the {@linkplain Function} {@code before3} to the
+     * Returns a composed function that first applies the {@linkplain Function} {@code before} to the
      * 3rd argument and then applies this CheckedFunction3 to the result and the other arguments.
      *
-     * @param <S> argument type of before3
-     * @param before3 the function applied before this
-     * @return a function composed of before3 and this
-     * @throws NullPointerException if before3 is null
+     * @param <S> argument type of before
+     * @param before the function applied before this
+     * @return a function composed of before and this
+     * @throws NullPointerException if before is null
      */
-    default <S> CheckedFunction3<T1, T2, S, R> compose3(Function1<? super S, ? extends T3> before3) {
-        Objects.requireNonNull(before3, "before3 is null");
-        return (T1 t1, T2 t2, S s) -> apply(t1, t2, before3.apply(s));
+    default <S> CheckedFunction3<T1, T2, S, R> compose3(Function1<? super S, ? extends T3> before) {
+        Objects.requireNonNull(before, "before is null");
+        return (T1 t1, T2 t2, S s) -> apply(t1, t2, before.apply(s));
     }
 }
 

vavr/src-gen/main/java/io/vavr/CheckedFunction4.java

@@ -121,7 +121,6 @@ static <T1, T2, T3, T4, R> CheckedFunction4<T1, T2, T3, T4, R> of(CheckedFunctio
      * @return a function that applies arguments to the given {@code partialFunction} and returns {@code Some(result)}
      *         if the function is defined for the given arguments, and {@code None} otherwise.
      */
-    @SuppressWarnings("RedundantTypeArguments")
     static <T1, T2, T3, T4, R> Function4<T1, T2, T3, T4, Option<R>> lift(CheckedFunction4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> partialFunction) {
         return (t1, t2, t3, t4) -> Try.<R>of(() -> partialFunction.apply(t1, t2, t3, t4)).toOption();
     }
@@ -331,59 +330,59 @@ default <V> CheckedFunction4<T1, T2, T3, T4, V> andThen(CheckedFunction1<? super
     }
 
     /**
-     * Returns a composed function that first applies the {@linkplain Function} {@code before1} to the
+     * Returns a composed function that first applies the {@linkplain Function} {@code before} to the
      * 1st argument and then applies this CheckedFunction4 to the result and the other arguments.
      *
-     * @param <S> argument type of before1
-     * @param before1 the function applied before this
-     * @return a function composed of before1 and this
-     * @throws NullPointerException if before1 is null
+     * @param <S> argument type of before
+     * @param before the function applied before this
+     * @return a function composed of before and this
+     * @throws NullPointerException if before is null
      */
-    default <S> CheckedFunction4<S, T2, T3, T4, R> compose1(Function1<? super S, ? extends T1> before1) {
-        Objects.requireNonNull(before1, "before1 is null");
-        return (S s, T2 t2, T3 t3, T4 t4) -> apply(before1.apply(s), t2, t3, t4);
+    default <S> CheckedFunction4<S, T2, T3, T4, R> compose1(Function1<? super S, ? extends T1> before) {
+        Objects.requireNonNull(before, "before is null");
+        return (S s, T2 t2, T3 t3, T4 t4) -> apply(before.apply(s), t2, t3, t4);
     }
 
     /**
-     * Returns a composed function that first applies the {@linkplain Function} {@code before2} to the
+     * Returns a composed function that first applies the {@linkplain Function} {@code before} to the
      * 2nd argument and then applies this CheckedFunction4 to the result and the other arguments.
      *
-     * @param <S> argument type of before2
-     * @param before2 the function applied before this
-     * @return a function composed of before2 and this
-     * @throws NullPointerException if before2 is null
+     * @param <S> argument type of before
+     * @param before the function applied before this
+     * @return a function composed of before and this
+     * @throws NullPointerException if before is null
      */
-    default <S> CheckedFunction4<T1, S, T3, T4, R> compose2(Function1<? super S, ? extends T2> before2) {
-        Objects.requireNonNull(before2, "before2 is null");
-        return (T1 t1, S s, T3 t3, T4 t4) -> apply(t1, before2.apply(s), t3, t4);
+    default <S> CheckedFunction4<T1, S, T3, T4, R> compose2(Function1<? super S, ? extends T2> before) {
+        Objects.requireNonNull(before, "before is null");
+        return (T1 t1, S s, T3 t3, T4 t4) -> apply(t1, before.apply(s), t3, t4);
     }
 
     /**
-     * Returns a composed function that first applies the {@linkplain Function} {@code before3} to the
+     * Returns a composed function that first applies the {@linkplain Function} {@code before} to the
      * 3rd argument and then applies this CheckedFunction4 to the result and the other arguments.
      *
-     * @param <S> argument type of before3
-     * @param before3 the function applied before this
-     * @return a function composed of before3 and this
-     * @throws NullPointerException if before3 is null
+     * @param <S> argument type of before
+     * @param before the function applied before this
+     * @return a function composed of before and this
+     * @throws NullPointerException if before is null
      */
-    default <S> CheckedFunction4<T1, T2, S, T4, R> compose3(Function1<? super S, ? extends T3> before3) {
-        Objects.requireNonNull(before3, "before3 is null");
-        return (T1 t1, T2 t2, S s, T4 t4) -> apply(t1, t2, before3.apply(s), t4);
+    default <S> CheckedFunction4<T1, T2, S, T4, R> compose3(Function1<? super S, ? extends T3> before) {
+        Objects.requireNonNull(before, "before is null");
+        return (T1 t1, T2 t2, S s, T4 t4) -> apply(t1, t2, before.apply(s), t4);
     }
 
     /**
-     * Returns a composed function that first applies the {@linkplain Function} {@code before4} to the
+     * Returns a composed function that first applies the {@linkplain Function} {@code before} to the
      * 4th argument and then applies this CheckedFunction4 to the result and the other arguments.
      *
-     * @param <S> argument type of before4
-     * @param before4 the function applied before this
-     * @return a function composed of before4 and this
-     * @throws NullPointerException if before4 is null
+     * @param <S> argument type of before
+     * @param before the function applied before this
+     * @return a function composed of before and this
+     * @throws NullPointerException if before is null
      */
-    default <S> CheckedFunction4<T1, T2, T3, S, R> compose4(Function1<? super S, ? extends T4> before4) {
-        Objects.requireNonNull(before4, "before4 is null");
-        return (T1 t1, T2 t2, T3 t3, S s) -> apply(t1, t2, t3, before4.apply(s));
+    default <S> CheckedFunction4<T1, T2, T3, S, R> compose4(Function1<? super S, ? extends T4> before) {
+        Objects.requireNonNull(before, "before is null");
+        return (T1 t1, T2 t2, T3 t3, S s) -> apply(t1, t2, t3, before.apply(s));
     }
 }