Mal eine neue Idee an der Tupel-Front: Ein naheliegendes Einsatzgebiet für Tuples wären Hilfsmethoden, um für die erweiterte for-Schleife so etwas Ähnliches wie List-Comprehensions realisieren zu können. Die Syntax wäre dann etwa so:
List<Integer> ints = ...
List<String> strings = ...
for(Pair<Integer, String> pair : combine(filter(ints, x -> x % 2 == 0), strings)) {
...
}
Die Methoden würden alle auf Iterable-Level arbeiten. Hier ein paar nützliche Signaturen:
//Kreuzprodukt a.k.a. Kombinationen
public static <A, B> Iterable<Pair<A, B>> combine(Iterable<A> itA, Iterable<B> itB);
public static <A, B, C> Iterable<Triple<A, B, C>> combine(Iterable<A> itA, Iterable<B> itB, Iterable<C> itC);
public static <A, B, C, D> Iterable<Quadruple<A, B, C, D>> combine(Iterable<A> itA, Iterable<B> itB, Iterable<C> itC, Iterable<D> itD);
public static <A, B, C> Iterable<C> combineWith(Iterable<A> itA, Iterable<B> itB, , BiFunction<A,B,C> fn);
public static <A, B, C, D> Iterable<D> combineWith(Iterable<A> itA, Iterable<B> itB, Iterable<C> itC, TriFunction<A,B,C,D> fn);
public static <A, B, C, D, E> Iterable<E> combineWith(Iterable<A> itA, Iterable<B> itB, Iterable<C> itC, Iterable<D> itD, QuadFunction<A,B,C,D,E> fn);
//Parallelverkettung
public static <A, B> Iterable<Pair<A, B>> zip(Iterable<A> itA, Iterable<B> itB);
public static <A, B, C> Iterable<Triple<A, B, C>> zip(Iterable<A> itA, Iterable<B> itB, Iterable<C> itC);
public static <A, B, C, D> Iterable<Quadruple<A, B, C, D>> zip(Iterable<A> itA, Iterable<B> itB, Iterable<C> itC, Iterable<D> itD);
public static <A, B, C> Iterable<C> zipWith(Iterable<A> itA, Iterable<B> itB, BiFunction<A,B,C> fn);
public static <A, B, C, D> Iterable<D> zipWith(Iterable<A> itA, Iterable<B> itB, Iterable<C> itC, TriFunction<A,B,C,D> fn);
public static <A, B, C, D, E> Iterable<E> zipWith(Iterable<A> itA, Iterable<B> itB, Iterable<C> itC, Iterable<D> itD, QuadFunction<A,B,C,D,E> fn);
//Hilfsmethoden
public static <A> Iterable<A> filter(Iterable<A> itA, Predicate<A> predA);
public static <A, B> Iterable<B> map(Iterable<A> itA, Function<A, B> fn);
public static <A, B> Iterable<B> flatMap(Iterable<A> itA, Function<A, ? extends Iterable<B>> fn);
public static <A> Iterable<A> flatten(Iterable<? extends Iterable<A>> nested);
public static <A> Iterable<A> array(A ... a); //Array als Iterable verwenden
public static <A> Iterable<A> optional(Optional<A> a); //Optional als Iterable verwenden
Was meint ihr dazu?