Utilisation fonctionnelle combinators sur Scala Tuples?

'map' conserve le nombre d'éléments, afin de l'utiliser sur un Tuple semble raisonnable.

Mes tentatives jusqu'à présent:

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)

Il semble assez douloureux... Et je n'ai même pas commencé à essayer de la convertir à un n-uplet.

Suis-je le fais mal? Pourrait la bibliothèque-elle être améliorée?

Il semblerait que vous utilisez un tuple où vous devriez vraiment être à l'aide d'une collection. Envisager l'utilisation d'un réel de la collection de la classe au lieu - tuples ne doit pas être utilisé comme une sorte de collections.
Je suis en désaccord: je pourrait tout simplement d'appliquer la même opération SEC vient et consicely sur une collection d'élément dont la taille est connu statiquement.

InformationsquelleAutor Eldritch Conundrum | 2010-02-26

informes Prend en charge le mappage et de pliage sur les tuples par l'intermédiaire d'un HList représentation,

Échantillon de RÉPLICATION de session,

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)

Où les éléments du tuple sont de différents types, vous pouvez mapper une fonction polymorphe avec le type spécifique de cas,

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)

Mise à jour

Que d'informes 2.0.0-M1 la cartographie de plus de tuples est pris en charge directement. Les exemples ci-dessus ressemble maintenant à ceci,

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)

C'est génial! Je voudrais marquer votre réponse acceptée, mais je ne sais pas si c'est ok pour modifier les accepté de réponse après plusieurs années.
Vous devez accepter le fait selon la réponse que vous pensez est le meilleur. Si les circonstances ou votre opinion changements au fil du temps, alors je pense que c'est raisonnable de mettre à jour votre acceptation en conséquence.
À mon humble avis, ce genre de choses est trop abstrait. Je veux dire, il doit importer des 3 espaces de noms (import xxxxx._) et pour les cas générique, il faut aussi beaucoup d'autres implicites comme type d'élément de la n-uplets. Cela dépend des cas d'utilisation, mais, plus probablement, que d'un simple code explicite serait plus lisible sans perte d'efficacité.
object double extends (Int -> Int) (_*2) provoque mon IDE de freak. WTF est cette ligne faire?

InformationsquelleAutor Miles Sabin

35

En général, le type d'élément d'un tuple ne sont pas les mêmes, de sorte que la carte n'a pas de sens. Vous pouvez définir une fonction pour gérer le cas particulier, même si:
```
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)
```
Vous pouvez utiliser le Pimp Ma Bibliothèque modèle d'appeler cela comme p.map(_ * 2).

Mise à JOUR

Même si les types des éléments qui ne sont pas les mêmes, Tuple2[A, B] est un Bifunctor, qui peuvent être mises en correspondance avec les bimap opération.
```
scala> import scalaz._
import scalaz._

scala> import Scalaz._
import Scalaz._

scala> val f = (_: Int) * 2
f: (Int) => Int = <function1>

scala> val g = (_: String) * 2
g: (String) => String = <function1>

scala> f <-: (1, "1") :-> g
res12: (Int, String) = (2,11)
```
Mise à JOUR 2

http://gist.github.com/454818
- Pour le rendu, je vais changer la accepté de répondre à partir de ce pour la plus récente de répondre au sujet de l'Informe, de la bibliothèque, ce qui n'était pas disponible en 2010.
InformationsquelleAutor retronym
1

fonction map obtient une A => B et retourne F[B].
```
def map[A, B](f: A => B) : F[B]
```
Comme retronym a écrit Tuple2[A, B] est un Bifunctor, de sorte que vous pouvez regarder pour le bimap fonction de scalaz ou les chats.

bimap est une fonction que les cartes des deux côtés de la n-uplet:
```
def bimap[A, B, C, D](fa: A => C, fb: B => D): Tuple2[C, D]
```
Parce que Tuple[A, B] contient 2 valeurs et une seule valeur peut être mappé (par convention, la valeur de droite), vous pouvez simplement retourner la même valeur pour le côté gauche et utilisez le bouton droit de
fonction de la carte sur la droite de la valeur du tuple.
```
(3, 4).bimap(identity, _ * 2)
```
InformationsquelleAutor Sagi

Vous devez vous connecter pour publier un commentaire.