Add append methods to all Px classes. Fix #326

janbols · jbgi · commit 065ed439303e · 2017-11-06T20:09:10.000+01:00
diff --git a/core/src/main/java/fj/P2.java b/core/src/main/java/fj/P2.java
@@ -178,7 +178,68 @@ public final P1<B> _2_() {
     return F1Functions.lazy(P2.<A, B>__2()).f(this);
   }
 
-    /**
+  /**
+   * Creates a {@link P3} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P3} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C> P3<A, B, C> append(C el) {
+    return P.p(_1(), _2(), el);
+  }
+
+  /**
+   * Creates a {@link P4} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P4} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C, D> P4<A, B, C, D> append(P2<C, D> el) {
+    return P.p(_1(), _2(), el._1(), el._2());
+  }
+
+  /**
+   * Creates a {@link P5} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P5} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C, D, E> P5<A, B, C, D, E> append(P3<C, D, E> el) {
+    return P.p(_1(), _2(), el._1(), el._2(), el._3());
+  }
+
+  /**
+   * Creates a {@link P6} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P6} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C, D, E, F> P6<A, B, C, D, E, F> append(P4<C, D, E, F> el) {
+    return P.p(_1(), _2(), el._1(), el._2(), el._3(), el._4());
+  }
+
+  /**
+   * Creates a {@link P7} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P7} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C, D, E, F, G> P7<A, B, C, D, E, F, G> append(P5<C, D, E, F, G> el) {
+    return P.p(_1(), _2(), el._1(), el._2(), el._3(), el._4(), el._5());
+  }
+
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C, D, E, F, G, H> P8<A, B, C, D, E, F, G, H> append(P6<C, D, E, F, G, H> el) {
+    return P.p(_1(), _2(), el._1(), el._2(), el._3(), el._4(), el._5(), el._6());
+  }
+
+
+  /**
      * Provides a memoising P2 that remembers its values.
      *
      * @return A P2 that calls this P2 once for any given element and remembers the value for subsequent calls.
diff --git a/core/src/main/java/fj/P3.java b/core/src/main/java/fj/P3.java
@@ -122,6 +122,58 @@ public final P1<C> _3_() {
     return F1Functions.lazy(P3.<A, B, C>__3()).f(this);
   }
 
+
+  /**
+   * Creates a {@link P4} by adding the given element to the current {@link P3}
+   *
+   * @param el the element to append
+   * @return A {@link P4} containing the original {@link P3} with the extra element added at the end
+   */
+  public final <D> P4<A, B, C, D> append(D el) {
+    return P.p(_1(), _2(), _3(), el);
+  }
+
+  /**
+   * Creates a {@link P5} by adding the given element to the current {@link P3}
+   *
+   * @param el the element to append
+   * @return A {@link P5} containing the original {@link P3} with the extra element added at the end
+   */
+  public final <D, E> P5<A, B, C, D, E> append(P2<D, E> el) {
+    return P.p(_1(), _2(), _3(), el._1(), el._2());
+  }
+
+  /**
+   * Creates a {@link P6} by adding the given element to the current {@link P3}
+   *
+   * @param el the element to append
+   * @return A {@link P6} containing the original {@link P3} with the extra element added at the end
+   */
+  public final <D, E, F> P6<A, B, C, D, E, F> append(P3<D, E, F> el) {
+    return P.p(_1(), _2(), _3(), el._1(), el._2(), el._3());
+  }
+
+  /**
+   * Creates a {@link P7} by adding the given element to the current {@link P3}
+   *
+   * @param el the element to append
+   * @return A {@link P7} containing the original {@link P3} with the extra element added at the end
+   */
+  public final <D, E, F, G> P7<A, B, C, D, E, F, G> append(P4<D, E, F, G> el) {
+    return P.p(_1(), _2(), _3(), el._1(), el._2(), el._3(), el._4());
+  }
+
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P3}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P3} with the extra element added at the end
+   */
+  public final <D, E, F, G, H> P8<A, B, C, D, E, F, G, H> append(P5<D, E, F, G, H> el) {
+    return P.p(_1(), _2(), _3(), el._1(), el._2(), el._3(), el._4(), el._5());
+  }
+
+
   /**
    * Provides a memoising P3 that remembers its values.
    *
diff --git a/core/src/main/java/fj/P4.java b/core/src/main/java/fj/P4.java
@@ -176,6 +176,50 @@ public final P1<D> _4_() {
     return F1Functions.lazy(P4.<A, B, C, D>__4()).f(this);
   }
 
+
+  /**
+   * Creates a {@link P5} by adding the given element to the current {@link P4}
+   *
+   * @param el the element to append
+   * @return A {@link P5} containing the original {@link P4} with the extra element added at the end
+   */
+  public final <E> P5<A, B, C, D, E> append(E el) {
+    return P.p(_1(), _2(), _3(), _4(), el);
+  }
+
+  /**
+   * Creates a {@link P6} by adding the given element to the current {@link P4}
+   *
+   * @param el the element to append
+   * @return A {@link P6} containing the original {@link P4} with the extra element added at the end
+   */
+  public final <E, F> P6<A, B, C, D, E, F> append(P2<E, F> el) {
+    return P.p(_1(), _2(), _3(), _4(), el._1(), el._2());
+  }
+
+  /**
+   * Creates a {@link P7} by adding the given element to the current {@link P4}
+   *
+   * @param el the element to append
+   * @return A {@link P7} containing the original {@link P4} with the extra element added at the end
+   */
+  public final <E, F, G> P7<A, B, C, D, E, F, G> append(P3<E, F, G> el) {
+    return P.p(_1(), _2(), _3(), _4(), el._1(), el._2(), el._3());
+  }
+
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P4}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P4} with the extra element added at the end
+   */
+  public final <E, F, G, H> P8<A, B, C, D, E, F, G, H> append(P4<E, F, G, H> el) {
+    return P.p(_1(), _2(), _3(), _4(), el._1(), el._2(), el._3(), el._4());
+  }
+
+
+
+
   /**
    * Provides a memoising P4 that remembers its values.
    *
diff --git a/core/src/main/java/fj/P5.java b/core/src/main/java/fj/P5.java
@@ -238,6 +238,36 @@ public final P1<E> _5_() {
     return F1Functions.lazy(P5.<A, B, C, D, E>__5()).f(this);
   }
 
+  /**
+   * Creates a {@link P6} by adding the given element to the current {@link P5}
+   *
+   * @param el the element to append
+   * @return A {@link P6} containing the original {@link P5} with the extra element added at the end
+   */
+  public final <F> P6<A, B, C, D, E, F> append(F el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), el);
+  }
+
+  /**
+   * Creates a {@link P7} by adding the given element to the current {@link P5}
+   *
+   * @param el the element to append
+   * @return A {@link P7} containing the original {@link P5} with the extra element added at the end
+   */
+  public final <F, G> P7<A, B, C, D, E, F, G> append(P2<F, G> el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), el._1(), el._2());
+  }
+
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P5}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P5} with the extra element added at the end
+   */
+  public final <F, G, H> P8<A, B, C, D, E, F, G, H> append(P3<F, G, H> el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), el._1(), el._2(), el._3());
+  }
+
   /**
    * Provides a memoising P5 that remembers its values.
    *
diff --git a/core/src/main/java/fj/P6.java b/core/src/main/java/fj/P6.java
@@ -309,6 +309,26 @@ public final P1<F> _6_() {
     return F1Functions.lazy(P6.<A, B, C, D, E, F>__6()).f(this);
   }
 
+  /**
+   * Creates a {@link P7} by adding the given element to the current {@link P6}
+   *
+   * @param el the element to append
+   * @return A {@link P7} containing the original {@link P6} with the extra element added at the end
+   */
+  public final <G> P7<A, B, C, D, E, F, G> append(G el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), _6(), el);
+  }
+
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P6}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P6} with the extra element added at the end
+   */
+  public final <G, H> P8<A, B, C, D, E, F, G, H> append(P2<G, H> el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), _6(), el._1(), el._2());
+  }
+
   /**
    * Provides a memoising P6 that remembers its values.
    *
diff --git a/core/src/main/java/fj/P7.java b/core/src/main/java/fj/P7.java
@@ -387,6 +387,16 @@ public final P1<G> _7_() {
     return F1Functions.lazy(P7.<A, B, C, D, E, F, G>__7()).f(this);
   }
 
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P7}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P7} with the extra element added at the end
+   */
+  public final <H> P8<A, B, C, D, E, F, G, H> append(H el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), _6(), _7(), el);
+  }
+
   /**
    * Provides a memoising P7 that remembers its values.
    *
