Utilizzare i combinatori funzionali su Scala Tuples?

‘map’ conserva il numero di elementi, quindi usarlo su una tupla sembra ragionevole.

I miei tentativi finora:

scala> (3,4).map(_*2) error: value map is not a member of (Int, Int) (3,4).map(_*2) ^ scala> (3,4).productIterator.map(_*2) error: value * is not a member of Any (3,4).productIterator.map(_*2) ^ scala> (3,4).productIterator.map(_.asInstanceOf[Int]*2) res4: Iterator[Int] = non-empty iterator scala> (3,4).productIterator.map(_.asInstanceOf[Int]*2).toList res5: List[Int] = List(6, 8) 

Sembra piuttosto doloroso … E non ho nemmeno iniziato a provare a convertirlo in una tupla.
Sto sbagliando? La libreria potrebbe essere migliorata?

Supporta la mapping e la piegatura di tuple tramite una rappresentazione HList intermedia,

Esempio di sessione REPL,

 scala> import shapeless._ ; import Tuples._ import shapeless._ import Tuples._ scala> object double extends (Int -> Int) (_*2) defined module double scala> (3, 4).hlisted.map(double).tupled res0: (Int, Int) = (6,8) 

Dove gli elementi della tupla sono di tipi diversi puoi mappare con una funzione polimorfica con casi specifici del tipo,

 scala> object frob extends Poly1 { | implicit def caseInt = at[Int](_*2) | implicit def caseString = at[String]("!"+_+"!") | implicit def caseBoolean = at[Boolean](!_) | } defined module frob scala> (23, "foo", false, "bar", 13).hlisted.map(frob).tupled res1: (Int, String, Boolean, String, Int) = (46,!foo!,true,!bar!,26) 

Aggiornare

A partire da 2.0.0-M1 senza forma la mapping su tuple è supportata direttamente. Gli esempi sopra ora sembrano così,

 scala> import shapeless._, poly._, syntax.std.tuple._ import shapeless._ import poly._ import syntax.std.tuple._ scala> object double extends (Int -> Int) (_*2) defined module double scala> (3, 4) map double res0: (Int, Int) = (6,8) scala> object frob extends Poly1 { | implicit def caseInt = at[Int](_*2) | implicit def caseString = at[String]("!"+_+"!") | implicit def caseBoolean = at[Boolean](!_) | } defined module frob scala> (23, "foo", false, "bar", 13) map frob res1: (Int, String, Boolean, String, Int) = (46,!foo!,true,!bar!,26) 

In generale, i tipi di elementi di una tupla non sono gli stessi, quindi la mappa non ha senso. È ansible definire una funzione per gestire il caso speciale, tuttavia:

 scala> def map[A, B](as: (A, A))(f: A => B) = as match { case (a1, a2) => (f(a1), f(a2)) } map: [A,B](as: (A, A))(f: (A) => B)(B, B) scala> val p = (1, 2) p: (Int, Int) = (1,2) scala> map(p){ _ * 2 } res1: (Int, Int) = (2,4) 

Potresti usare il pattern Pimp My Library per chiamarlo p.map(_ * 2) .

AGGIORNARE

Anche quando i tipi di elementi non sono uguali, Tuple2[A, B] è un Bifunctor , che può essere mappato con l’operazione bimap .

 scala> import scalaz._ import scalaz._ scala> import Scalaz._ import Scalaz._ scala> val f = (_: Int) * 2 f: (Int) => Int =  scala> val g = (_: String) * 2 g: (String) => String =  scala> f <-: (1, "1") :-> g res12: (Int, String) = (2,11) 

AGGIORNAMENTO 2

http://gist.github.com/454818