स्कैला टुपल्स पर कार्यात्मक संयोजक का उपयोग करें?

Question

'नक्शा' तत्वों की संख्या को संरक्षित करता है, इसलिए इसे टुपल पर उपयोग करना समझदार लगता है।

मेरे प्रयास अब तक:

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) 

यह काफी दर्दनाक लग रहा है ... और मैं भी एक टपल करने के लिए इसे वापस बदलने की कोशिश करने के लिए शुरू नहीं किया है।
क्या मैं इसे गलत कर रहा हूं? पुस्तकालय में सुधार किया जा सकता है?

Answer 1

shapeless मानचित्रण और एक मध्यस्थ के HList प्रतिनिधित्व के माध्यम से tuples की तह का समर्थन करता है,

नमूना आरईपीएल सत्र,

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) 

कहाँ टपल के तत्वों विभिन्न प्रकार आप विशेष प्रकार के मामलों के साथ एक बहुरूपी समारोह के साथ मैप कर सकते हैं के हैं,

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) 

अद्यतन

tuples की निराकार 2.0.0-M1 मानचित्रण के रूप में सीधे समर्थित है। उपर्युक्त उदाहरण अब इस तरह दिखते हैं,

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) 

Answer 2

सामान्य रूप से, ट्यूपल के तत्व प्रकार समान नहीं होते हैं, इसलिए नक्शा समझ में नहीं आता है। आप विशेष मामला संभाल करने, हालांकि एक समारोह को परिभाषित कर सकते हैं:

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) 

आप p.map(_ * 2) के रूप में इस कॉल करने के लिए दलाल मेरी लाइब्रेरी पैटर्न का उपयोग कर सकते हैं।

अद्यतन

यहां तक ​​कि जब तत्वों के प्रकार ही नहीं हैं, Tuple2[A, B] एक Bifunctor, जो bimap संचालन के साथ मैप किया जा सकता है।

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) 

अद्यतन 2

http://gist.github.com/454818