001    package fj;
002    
003    /**
004     * Functions across products.
005     *
006     * @version %build.number%<br>
007     *          <ul>
008     *          <li>$LastChangedRevision: 5 $</li>
009     *          <li>$LastChangedDate: 2008-12-06 16:49:43 +1000 (Sat, 06 Dec 2008) $</li>
010     *          </ul>
011     */
012    public final class P {
013      private P() {
014        throw new UnsupportedOperationException();
015      }
016    
017      /**
018       * A function that puts an element in a product-1.
019       *
020       * @return A function that puts an element in a product-1.
021       */
022      public static <A> F<A, P1<A>> p1() {
023        return new F<A, P1<A>>() {
024          public P1<A> f(final A a) {
025            return p(a);
026          }
027        };
028      }
029    
030      /**
031       * A function that puts an element in a product-1.
032       *
033       * @param a The element.
034       * @return The product-1.
035       */
036      public static <A> P1<A> p(final A a) {
037        return new P1<A>() {
038          public A _1() {
039            return a;
040          }
041        };
042      }
043    
044      /**
045       * A function that puts an element in a product-2.
046       *
047       * @return A function that puts an element in a product-2.
048       */
049      public static <A, B> F<A, F<B, P2<A, B>>> p2() {
050        return new F<A, F<B, P2<A, B>>>() {
051          public F<B, P2<A, B>> f(final A a) {
052            return new F<B, P2<A, B>>() {
053              public P2<A, B> f(final B b) {
054                return p(a, b);
055              }
056            };
057          }
058        };
059      }
060    
061      /**
062       * A function that puts elements in a product-2.
063       *
064       * @param a An element.
065       * @param b An element.
066       * @return The product-2.
067       */
068      public static <A, B> P2<A, B> p(final A a, final B b) {
069        return new P2<A, B>() {
070          public A _1() {
071            return a;
072          }
073    
074          public B _2() {
075            return b;
076          }
077        };
078      }
079    
080      /**
081       * A function that puts an element in a product-3.
082       *
083       * @return A function that puts an element in a product-3.
084       */
085      public static <A, B, C> F<A, F<B, F<C, P3<A, B, C>>>> p3() {
086        return new F<A, F<B, F<C, P3<A, B, C>>>>() {
087          public F<B, F<C, P3<A, B, C>>> f(final A a) {
088            return new F<B, F<C, P3<A, B, C>>>() {
089              public F<C, P3<A, B, C>> f(final B b) {
090                return new F<C, P3<A, B, C>>() {
091                  public P3<A, B, C> f(final C c) {
092                    return p(a, b, c);
093                  }
094                };
095              }
096            };
097          }
098        };
099      }
100    
101      /**
102       * A function that puts elements in a product-3.
103       *
104       * @param a An element.
105       * @param b An element.
106       * @param c An element.
107       * @return The product-3.
108       */
109      public static <A, B, C> P3<A, B, C> p(final A a, final B b, final C c) {
110        return new P3<A, B, C>() {
111          public A _1() {
112            return a;
113          }
114    
115          public B _2() {
116            return b;
117          }
118    
119          public C _3() {
120            return c;
121          }
122        };
123      }
124    
125      /**
126       * A function that puts an element in a product-4.
127       *
128       * @return A function that puts an element in a product-4.
129       */
130      public static <A, B, C, D> F<A, F<B, F<C, F<D, P4<A, B, C, D>>>>> p4() {
131        return new F<A, F<B, F<C, F<D, P4<A, B, C, D>>>>>() {
132          public F<B, F<C, F<D, P4<A, B, C, D>>>> f(final A a) {
133            return new F<B, F<C, F<D, P4<A, B, C, D>>>>() {
134              public F<C, F<D, P4<A, B, C, D>>> f(final B b) {
135                return new F<C, F<D, P4<A, B, C, D>>>() {
136                  public F<D, P4<A, B, C, D>> f(final C c) {
137                    return new F<D, P4<A, B, C, D>>() {
138                      public P4<A, B, C, D> f(final D d) {
139                        return p(a, b, c, d);
140                      }
141                    };
142                  }
143                };
144              }
145            };
146          }
147        };
148      }
149    
150      /**
151       * A function that puts elements in a product-4.
152       *
153       * @param a An element.
154       * @param b An element.
155       * @param c An element.
156       * @param d An element.
157       * @return The product-4.
158       */
159      public static <A, B, C, D> P4<A, B, C, D> p(final A a, final B b, final C c, final D d) {
160        return new P4<A, B, C, D>() {
161          public A _1() {
162            return a;
163          }
164    
165          public B _2() {
166            return b;
167          }
168    
169          public C _3() {
170            return c;
171          }
172    
173          public D _4() {
174            return d;
175          }
176        };
177      }
178    
179      /**
180       * A function that puts an element in a product-5.
181       *
182       * @return A function that puts an element in a product-5.
183       */
184      public static <A, B, C, D, E> F<A, F<B, F<C, F<D, F<E, P5<A, B, C, D, E>>>>>> p5() {
185        return new F<A, F<B, F<C, F<D, F<E, P5<A, B, C, D, E>>>>>>() {
186          public F<B, F<C, F<D, F<E, P5<A, B, C, D, E>>>>> f(final A a) {
187            return new F<B, F<C, F<D, F<E, P5<A, B, C, D, E>>>>>() {
188              public F<C, F<D, F<E, P5<A, B, C, D, E>>>> f(final B b) {
189                return new F<C, F<D, F<E, P5<A, B, C, D, E>>>>() {
190                  public F<D, F<E, P5<A, B, C, D, E>>> f(final C c) {
191                    return new F<D, F<E, P5<A, B, C, D, E>>>() {
192                      public F<E, P5<A, B, C, D, E>> f(final D d) {
193                        return new F<E, P5<A, B, C, D, E>>() {
194                          public P5<A, B, C, D, E> f(final E e) {
195                            return p(a, b, c, d, e);
196                          }
197                        };
198                      }
199                    };
200                  }
201                };
202              }
203            };
204          }
205        };
206      }
207    
208      /**
209       * A function that puts elements in a product-5.
210       *
211       * @param a An element.
212       * @param b An element.
213       * @param c An element.
214       * @param d An element.
215       * @param e An element.
216       * @return The product-5.
217       */
218      public static <A, B, C, D, E> P5<A, B, C, D, E> p(final A a, final B b, final C c, final D d, final E e) {
219        return new P5<A, B, C, D, E>() {
220          public A _1() {
221            return a;
222          }
223    
224          public B _2() {
225            return b;
226          }
227    
228          public C _3() {
229            return c;
230          }
231    
232          public D _4() {
233            return d;
234          }
235    
236          public E _5() {
237            return e;
238          }
239        };
240      }
241    
242      /**
243       * A function that puts an element in a product-6.
244       *
245       * @return A function that puts an element in a product-6.
246       */
247      public static <A, B, C, D, E, F$> F<A, F<B, F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>>>> p6() {
248        return new F<A, F<B, F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>>>>() {
249          public F<B, F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>>> f(final A a) {
250            return new F<B, F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>>>() {
251              public F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>> f(final B b) {
252                return new F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>>() {
253                  public F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>> f(final C c) {
254                    return new F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>() {
255                      public F<E, F<F$, P6<A, B, C, D, E, F$>>> f(final D d) {
256                        return new F<E, F<F$, P6<A, B, C, D, E, F$>>>() {
257                          public F<F$, P6<A, B, C, D, E, F$>> f(final E e) {
258                            return new F<F$, P6<A, B, C, D, E, F$>>() {
259                              public P6<A, B, C, D, E, F$> f(final F$ f) {
260                                return p(a, b, c, d, e, f);
261                              }
262                            };
263                          }
264                        };
265                      }
266                    };
267                  }
268                };
269              }
270            };
271          }
272        };
273      }
274    
275      /**
276       * A function that puts elements in a product-6.
277       *
278       * @param a An element.
279       * @param b An element.
280       * @param c An element.
281       * @param d An element.
282       * @param e An element.
283       * @param f An element.
284       * @return The product-6.
285       */
286      public static <A, B, C, D, E, F$> P6<A, B, C, D, E, F$> p(final A a, final B b, final C c, final D d, final E e, final F$ f) {
287        return new P6<A, B, C, D, E, F$>() {
288          public A _1() {
289            return a;
290          }
291    
292          public B _2() {
293            return b;
294          }
295    
296          public C _3() {
297            return c;
298          }
299    
300          public D _4() {
301            return d;
302          }
303    
304          public E _5() {
305            return e;
306          }
307    
308          public F$ _6() {
309            return f;
310          }
311        };
312      }
313    
314      /**
315       * A function that puts an element in a product-7.
316       *
317       * @return A function that puts an element in a product-7.
318       */
319      public static <A, B, C, D, E, F$, G> F<A, F<B, F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>>>> p7() {
320        return new F<A, F<B, F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>>>>() {
321          public F<B, F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>>> f(final A a) {
322            return new F<B, F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>>>() {
323              public F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>> f(final B b) {
324                return new F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>>() {
325                  public F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>> f(final C c) {
326                    return new F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>() {
327                      public F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>> f(final D d) {
328                        return new F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>() {
329                          public F<F$, F<G, P7<A, B, C, D, E, F$, G>>> f(final E e) {
330                            return new F<F$, F<G, P7<A, B, C, D, E, F$, G>>>() {
331                              public F<G, P7<A, B, C, D, E, F$, G>> f(final F$ f) {
332                                return new F<G, P7<A, B, C, D, E, F$, G>>() {
333                                  public P7<A, B, C, D, E, F$, G> f(final G g) {
334                                    return p(a, b, c, d, e, f, g);
335                                  }
336                                };
337                              }
338                            };
339                          }
340                        };
341                      }
342                    };
343                  }
344                };
345              }
346            };
347          }
348        };
349      }
350      
351      /**
352       * A function that puts elements in a product-7.
353       *
354       * @param a An element.
355       * @param b An element.
356       * @param c An element.
357       * @param d An element.
358       * @param e An element.
359       * @param f An element.
360       * @param g An element.
361       * @return The product-7.
362       */
363      public static <A, B, C, D, E, F$, G> P7<A, B, C, D, E, F$, G> p(final A a, final B b, final C c, final D d, final E e, final F$ f, final G g) {
364        return new P7<A, B, C, D, E, F$, G>() {
365          public A _1() {
366            return a;
367          }
368    
369          public B _2() {
370            return b;
371          }
372    
373          public C _3() {
374            return c;
375          }
376    
377          public D _4() {
378            return d;
379          }
380    
381          public E _5() {
382            return e;
383          }
384    
385          public F$ _6() {
386            return f;
387          }
388    
389          public G _7() {
390            return g;
391          }
392        };
393      }
394    
395      /**
396       * A function that puts an element in a product-8.
397       *
398       * @return A function that puts an element in a product-8.
399       */
400      public static <A, B, C, D, E, F$, G, H> F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>>>> p8() {
401        return new F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>>>>() {
402          public F<B, F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>>> f(final A a) {
403            return new F<B, F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>>>() {
404              public F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>> f(final B b) {
405                return new F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>>() {
406                  public F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>> f(final C c) {
407                    return new F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>() {
408                      public F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>> f(final D d) {
409                        return new F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>() {
410                          public F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>> f(final E e) {
411                            return new F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>() {
412                              public F<G, F<H, P8<A, B, C, D, E, F$, G, H>>> f(final F$ f) {
413                                return new F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>() {
414                                  public F<H, P8<A, B, C, D, E, F$, G, H>> f(final G g) {
415                                    return new F<H, P8<A, B, C, D, E, F$, G, H>>() {
416                                      public P8<A, B, C, D, E, F$, G, H> f(final H h) {
417                                        return p(a, b, c, d, e, f, g, h);
418                                      }
419                                    };
420                                  }
421                                };
422                              }
423                            };
424                          }
425                        };
426                      }
427                    };
428                  }
429                };
430              }
431            };
432          }
433        };
434      }
435    
436      /**
437       * A function that puts elements in a product-8.
438       *
439       * @param a An element.
440       * @param b An element.
441       * @param c An element.
442       * @param d An element.
443       * @param e An element.
444       * @param f An element.
445       * @param g An element.
446       * @param h An element.
447       * @return The product-8.
448       */
449      public static <A, B, C, D, E, F$, G, H> P8<A, B, C, D, E, F$, G, H> p(final A a, final B b, final C c, final D d, final E e, final F$ f, final G g, final H h) {
450        return new P8<A, B, C, D, E, F$, G, H>() {
451          public A _1() {
452            return a;
453          }
454    
455          public B _2() {
456            return b;
457          }
458    
459          public C _3() {
460            return c;
461          }
462    
463          public D _4() {
464            return d;
465          }
466    
467          public E _5() {
468            return e;
469          }
470    
471          public F$ _6() {
472            return f;
473          }
474    
475          public G _7() {
476            return g;
477          }
478    
479          public H _8() {
480            return h;
481          }
482        };
483      }
484    }