क्या मैं स्कैला 2.8 में एक टुपल (संरचना को परिभाषित कर सकता हूं?) नाम दे सकता हूं?

Question

हर बार मुझे इसकी आवश्यकता होने पर लाइन-लम्बी ट्यूपल परिभाषा को दोहराना हमेशा अच्छा नहीं लगता है। क्या मैं इसे अभी नाम दे सकता हूं और एक प्रकार के नाम के रूप में उपयोग कर सकता हूं? भी की बजाय अपने खेतों नाम के लिए अच्छा ._1, ._2 आदि

Answer 1

अपने पहले प्रश्न के बारे में उपयोग करते हुए किया जाएगा, तो आप बस एक प्रकार अन्य नाम का उपयोग कर सकते हैं:

type KeyValue = (Int, String) 

, निश्चित रूप से और, स्काला एक है

case class KeyValue(key: Int, value: String) extends (Int, String)(key, value) 

यह है कि: वस्तु उन्मुख भाषा है, तो कैसे एक टपल विशेषज्ञ के बारे में अपने दूसरे के बारे में, जादू शब्द विरासत है। कक्षा को शरीर की भी आवश्यकता नहीं है।

val kvp = KeyValue(42, "Hello") 
kvp._1 // => res0: Int = 42 
kvp.value // => res1: String = "Hello" 

हालांकि, ध्यान दें कि इस मामले वर्गों से इनहेरिट (जो Tuple2 है), तो बहिष्कृत किया जाता है और भविष्य में अनुमति नहीं दी जा सकती है। यहाँ संकलक आप ऊपर वर्ग परिभाषा के लिए मिलता है चेतावनी है:

चेतावनी: मामले वर्ग class KV मामले वर्ग पूर्वज class Tuple2 है। यह उपयोग और कार्यान्वयन दोनों को अनुचित रूप से जटिल करने के लिए बहिष्कृत कर दिया गया है। आपको गैर-पत्ती नोड्स पर पैटर्न मिलान के लिए निकालने वाले का उपयोग करना चाहिए।

Answer 2

प्रकार उर्फ ​​अपने टपल नामकरण, लेकिन बजाय एक मामले वर्ग का उपयोग कर प्रयास के लिए ठीक है। आप टपल साथ

उदाहरण नामित पैरामीटर का उपयोग करने में सक्षम हो जाएगा:

def foo(a : Int) : (Int, String) = { 
    (a,"bar") 
} 
val res = foo(1) 
val size = res._1 
val name= res._2 

एक मामले वर्ग के साथ

:

case class Result(size : Int , name : String) 
def foo(a : Int) : Result = { 
    Result(a,"bar") 
} 
val res = foo(1) 
val size = res.size 
val name= res.name 

Answer 3

यहाँ एक समाधान है कि एक प्रकार उर्फ ​​और एक कारखाने वस्तु बनाता है।

scala> type T = (Int, String)       
defined type alias T 

scala> object T { def apply(i: Int, s: String): T = (i, s) } 
defined module T 

scala> new T(1, "a") 
res0: (Int, String) = (1,a) 

scala> T(1, "a") 
res1: (Int, String) = (1,a) 

हालांकि अन्य लोगों ने उल्लेख किया है, तो आपको शायद एक केस क्लास बनाना चाहिए।

Answer 4

हालांकि अन्य लोगों ने कहा है, स्पष्ट (केस) कक्षा सामान्य अर्थ में सर्वोत्तम हैं।

val (first, second) = incrementPair(3, 4) 
println(s"$first ... $second") 

एक टपल लौटने के लिए एक विधि को देखते हुए:

def incrementPair(pair: (Int, Int)) : (Int, Int) = { 
    val (first, second) = pair 
    (first + 1, second + 1) 
}