public E _5() { return P7.this._5(); }
public E _5() { return P7.this._5(); }
public E _5() { return P7.this._5(); }
public A _4() { return p._5(); }
public E _5() { return P7.this._5(); }
public E _5() { return P7.this._5(); }
public E _5() { return P7.this._5(); }
public X _5() { return f.f(P7.this._5()); }
/** * 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); }
/** * An equal instance for a product-7. * * @param ea Equality across the first element of the product. * @param eb Equality across the second element of the product. * @param ec Equality across the third element of the product. * @param ed Equality across the fourth element of the product. * @param ee Equality across the fifth element of the product. * @param ef Equality across the sixth element of the product. * @param eg Equality across the seventh element of the product. * @return An equal instance for a product-7. */ public static <A, B, C, D, E, F$, G> Equal<P7<A, B, C, D, E, F$, G>> p7Equal(final Equal<A> ea, final Equal<B> eb, final Equal<C> ec, final Equal<D> ed, final Equal<E> ee, final Equal<F$> ef, final Equal<G> eg) { Definition<A> eaDef = ea.def; Definition<B> ebDef = eb.def; Definition<C> ecDef = ec.def; Definition<D> edDef = ed.def; Definition<E> eeDef = ee.def; Definition<F$> efDef = ef.def; Definition<G> egDef = eg.def; return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) && edDef.equal(p1._4(), p2._4()) && eeDef.equal(p1._5(), p2._5()) && efDef.equal(p1._6(), p2._6()) && egDef.equal(p1._7(), p2._7())); }
/** * A hash instance for a product-7. * * @param ha A hash for the first element of the product. * @param hb A hash for the second element of the product. * @param hc A hash for the third element of the product. * @param hd A hash for the fourth element of the product. * @param he A hash for the fifth element of the product. * @param hf A hash for the sixth element of the product. * @param hg A hash for the seventh element of the product. * @return A hash instance for a product-7. */ public static <A, B, C, D, E, F$, G> Hash<P7<A, B, C, D, E, F$, G>> p7Hash(final Hash<A> ha, final Hash<B> hb, final Hash<C> hc, final Hash<D> hd, final Hash<E> he, final Hash<F$> hf, final Hash<G> hg) { return hash(p7 -> { final int p = 419; int r = 239; r = p * r + ha.hash(p7._1()); r = p * r + hb.hash(p7._2()); r = p * r + hc.hash(p7._3()); r = p * r + hd.hash(p7._4()); r = p * r + he.hash(p7._5()); r = p * r + hf.hash(p7._6()); r = p * r + hg.hash(p7._7()); return r; }); }
/** * A show instance for the {@link P7 tuple-7} type. * * @param sa Show for the first element of the tuple. * @param sb Show for the second element of the tuple. * @param sc Show for the third element of the tuple. * @param sd Show for the fourth element of the tuple. * @param se Show for the fifth element of the tuple. * @param sf Show for the sixth element of the tuple. * @param sg Show for the seventh element of the tuple. * @return A show instance for the {@link P7 tuple-7} type. */ public static <A, B, C, D, E, F$, G> Show<P7<A, B, C, D, E, F$, G>> p7Show(final Show<A> sa, final Show<B> sb, final Show<C> sc, final Show<D> sd, final Show<E> se, final Show<F$> sf, final Show<G> sg) { return show(p -> cons('(', p(sa.show(p._1()))).snoc(',').append(sb.show(p._2())).snoc(',') .append(sc.show(p._3())).snoc(',').append(sd.show(p._4())).snoc(',') .append(se.show(p._5())).snoc(',').append(sf.show(p._6())).snoc(',').append(sg.show(p._7())).snoc(')')); }