स्काला चर तर्क सूची के साथ अंतर्निहित

Question

मैं पुस्तकालय विधि चर तर्क सूची ले रहे हैं और डेटा

class Data 
def process(elems: String*): Data = new Data 

उत्पादन किया है और मैं अपने तार परोक्ष Data

implicit def strToData(ts: String): Data = process(t) 

को परिवर्तित किया तो मैं कुछ लिख सकते हैं चाहता हूँ

val data: Data = "one" 

लेकिन मैं स्ट्रिंग्स के टुपल्स को इम्प्ली करना चाहता हूं citly भी रूपांतरित। मैं जोड़ दिया है एक और निहित

implicit def strsToData(ts: String*): Data = process(ts: _*) 

यह ठीक संकलित, लेकिन रूपांतरण विफल रहता है

val data: Data = ("one", "two") 
val dat3: Data = ("one", "two", "three") 
val dat4: Data = ("one", "two", "three", "four") 

found : Seq[java.lang.String] 
required: this.Data 
val data: Data = Seq("one", "two") 

साथ

वहाँ किसी भी तरह से tuples परोक्ष कन्वर्ट करने के लिए है, या एक कारण है कि यह कर सकते हैं सफल हो?

अद्यतन: टुपल्स किसी भी धर्मार्थ का हो सकता है।

Answer 1

जबकि @ NikitaVolkov के जवाब में सभी चेतावनियों डबल बल में लागू होते हैं, आप एक संस्करण है कि टपल के किसी भी arity स्वीकार करता है लिख सकते हैं, साथ ही साथ किसी भी मामले वर्ग:

implicit def prod2data(Product p): process((p.productIterator.toSeq):_*) 

Answer 2

आप Data करने के लिए एक टपल से एक अंतर्निहित रूपांतरण बनाने के लिए की आवश्यकता होगी:

implicit def strTplToData(ts:(String, String)) = process(ts._1, ts._2) 

तो फिर तुम कर सकता है:

val data: Data = ("one", "two") 

Answer 3

1. ts: String* एक टपल एक Iterable नहीं है, लेकिन। आप टिकाऊ को टिकाऊ रूपांतरित नहीं कर सकते हैं, क्योंकि ट्यूपल एक स्थिर प्रकार है और इसकी धैर्य संकलित समय पर हल हो जाती है। एमिल एच ने जवाब दिया कि आप टुपल से एक अंतर्निहित रूपांतरण कैसे कर सकते हैं।

2. एक प्रकार से दूसरे प्रकार के पारदर्शी निहित रूपांतरण एक आम गड़बड़ी है और बहुत निराश हैं। इसके बजाय आप एक "आवरण" दृष्टिकोण लागू करना चाहिए, या स्काला 2.10 के बाद से "मान कक्षाएं" का उपयोग करें:

   स्काला 2.9 में:

   implicit def stringStringTupleExtender (ts : (String, String)) = 
       new { 
       def data = process(ts) 
       } 
   

   स्काला 2.10 में:

   implicit class StringStringTupleExtender (val ts : (String, String)) extends AnyVal { 
       def data = process(ts) 
   } 
   

   तो फिर तुम हूँ इसलिए की तरह उपयोग:

   val data : Data = ("sdf", "lsdfj").data 
   val data1 : Data = "sdf".data // if you do the same for String 
   

3. आप गतिशील रूप से किसी भी इनपुट संग्रह को हल करने, फिर, अनुमान लिए देख रहे हैं क्या, आपको एक संग्रह का उपयोग करना चाहिए, न कि टुपल।

   स्कैला 2 में।9

   implicit def seqExtender (ts : Seq[String]) = 
       new { 
       def data = process(ts) 
       } 
   

   उपयोग:

   val data : Data = Seq("sdf", "lsdkfjsdl", "ldsfjk").data