Estoy tratando de construir múltiples productos cruzados de traversables de diferentes tipos (pero cada uno homogéneo). El tipo de retorno deseado es un atravesable de una tupla con el tipo que coincide con los tipos en los traversables de entrada. Por ejemplo:

List(1, 2, 3) cross Seq("a", "b") cross Set(0.5, 7.3)

Esto debería dar unaTraversable[(Int, String, Double)] Con todas las combinaciones posibles de las tres fuentes. El caso de combinar solo dos fuentes fue muy bien.respondido aqui. La idea dada es:

implicit class Crossable[X](xs: Traversable[X]) {
  def cross[A](ys: Traversable[A]) = for { x <- xs; y <- ys } yield (x, y)
}

Los comentarios allí mencionan brevemente el problema de más fuentes, pero estoy buscando una solución que no dependa de Shalaz o sin forma (por otro lado, no me importa tener algo para mejorar.Tuple22). Lo que me gustaría hacer es algo como lo siguiente:

implicit class Crossable[X](xs: Traversable[X]) {
  def cross[A](ys: Traversable[A]) = for { x <- xs; y <- ys } yield (x, y)
  def cross[A,B](ys: Traversable[(A,B)]) = // ... extend all Tuple2's in ys with x in xs to Tuple3's
  def cross[A,B,C](ys: Traversable[(A,B,C)]) = // ...
  // ...
}

Esto obviamente no funciona debido al borrado de tipo (y, desafortunadamente, probablemente se requiera usar paréntesis en el ejemplo anterior, porquecross Sería acertado asociativo).

Mi pregunta es: ¿Es posible explotar las características de reflexión de Scala 2.10 para resolver el problema? En general, emparejando ambosA yX a los diversos tipos de tuplas (y sus parámetros de tipo, que parecen ser desafiantes) y fusionarlos en tuplas más grandes debería proporcionar una solución que satisfaga la ley asociativa, ¿verdad?