Ich möchte die Elemente eines Scala-Tupels (oder Triple, ...) mit einer einzigen Funktion abbilden, die Typ R zurückgibt. Das Ergebnis sollte ein Tupel (oder Triple, ...) mit Elementen des Typs R sein.

OK, wenn die Elemente des Tupels vom selben Typ sind, ist die Zuordnung kein Problem:

scala> implicit def t2mapper[A](t: (A,A)) = new { def map[R](f: A => R) = (f(t._1),f(t._2)) }
t2mapper: [A](t: (A, A))java.lang.Object{def map[R](f: (A) => R): (R, R)}

scala> (1,2) map (_ + 1)
res0: (Int, Int) = (2,3)

Aber es ist auch möglich, diese Lösung generisch zu machen, d. H. Tupel, die Elemente unterschiedlichen Typs enthalten, auf dieselbe Weise abzubilden?

Beispiel

class Super(i: Int)
object Sub1 extends Super(1)
object Sub2 extends Super(2)

(Sub1, Sub2) map (_.i)

should return

(1,2): (Int, Int)

Aber ich konnte keine Lösung finden, so dass die Zuordnungsfunktion den Supertyp von Sub1 und Sub2 bestimmt. Ich habe versucht, Typgrenzen zu verwenden, aber meine Idee ist fehlgeschlagen:

scala> implicit def t2mapper[A,B](t: (A,B)) = new { def map[X >: A, X >: B, R](f: X => R) = (f(t._1),f(t._2)) }
<console>:8: error: X is already defined as type X
       implicit def t2mapper[A,B](t: (A,B)) = new { def map[X >: A, X >: B, R](f: X => R) = (f(t._1),f(t._2)) }
                                                                    ^
<console>:8: error: type mismatch;
 found   : A
 required: X
 Note: implicit method t2mapper is not applicable here because it comes after the application point and it lacks an explicit result type
       implicit def t2mapper[A,B](t: (A,B)) = new { def map[X >: A, X >: B, R](f: X => R) = (f(t._1),f(t._2)) }

HierX >: B scheint @ zu überschreibX >: A. Unterstützt Scala keine Typgrenzen für mehrere Typen? Wenn ja, warum nicht?