पैरामीटर क्या है: _ * स्कैला में मतलब है?

Question

स्काला (2.9.1) के लिए नए होने के नाते, मैं एक List[Event] है और एक Queue[Event] में कॉपी करना चाहते हैं, लेकिन निम्न सिंटेक्स एक Queue[List[Event]] पैदावार बजाय:

val eventQueue = Queue(events) 

किसी कारण, निम्न कार्य करता है:

val eventQueue = Queue(events : _*) 

लेकिन मैं समझना चाहता हूं कि यह क्या करता है, और यह क्यों काम करता है? मैं पहले से ही Queue.apply समारोह के हस्ताक्षर को देखा:

def apply[A](elems: A*) 

और मैं समझता हूँ कि क्यों पहला प्रयास काम नहीं करता है, लेकिन एक दूसरे का अर्थ क्या है? इस मामले में : और _* क्या है, और apply फ़ंक्शन क्यों नहीं है Iterable[A]?

Answer 1

a: A टाइप लिप्यंतरण है; देखें What is the purpose of type ascriptions in Scala?

: _* टाइप प्रकार का एक विशेष उदाहरण है जो संकलक को एक अनुक्रम प्रकार के एक तर्क के रूप में एक चर तर्क तर्क अनुक्रम के रूप में व्यवहार करने के लिए कहता है, यानी varargs।

यह पूरी तरह से एक QueueQueue.apply एक भी तत्व है जो एक दृश्य या iterable है कि का उपयोग कर बनाने के लिए मान्य है, तो यह है जब आप एक भी Iterable[A] देना वास्तव में क्या होता है।

Answer 2

यह एक विशेष संकेत है जो संकलक को प्रत्येक तत्व को एक तर्क के रूप में इसके बजाय अपने तर्क के रूप में पारित करने के लिए कहता है। here देखें।

यह एक प्रकार की एनोटेशन है जो अनुक्रम तर्क इंगित करता है और भाषा spec, "दोहराया पैरामीटर्स" की धारा 4.6.2 में सामान्य नियम के लिए "अपवाद" के रूप में वर्णित है।

यह तब उपयोगी होता है जब फ़ंक्शन में तर्कों की एक चर संख्या होती है, उदा। एक समारोह के रूप में def sum(args: Int*), तो आप एक तरह के रूप में xs = List(1,2,3) सूची है जो sum(1), sum(1,2) आदि के रूप में लागू किया जा सकता है, आप ही पारित कर सकते हैं नहीं xs, क्योंकि यह एक List बल्कि एक Int से है, लेकिन आप का उपयोग कर उसके तत्वों पारित कर सकते हैं sum(xs: _*)।

Answer 3

अजगर लोगों के लिए:

स्काला के _* ऑपरेटर कम या ज्यादा पायथन के *-operator के बराबर है।

---

उदाहरण

link से स्केला उदाहरण Luigi Plinge द्वारा प्रदान की परिवर्तित:

def echo(args: String*) = 
    for (arg <- args) println(arg) 

val arr = Array("What's", "up", "doc?") 
echo(arr: _*) 

अजगर को दिखाई देगा:

def echo(*args): 
    for arg in args: 
     print "%s" % arg 

arr = ["What's", "up", "doc?"] 
echo(*arr) 

और दोनों followin देना ग्राम उत्पादन:

What's
up
doc?

---

अंतर: खोल स्थितीय मापदंडों

पायथन के * -operator भी निश्चित arity कार्यों के लिए स्थितीय मापदंडों/पैरामीटर के खोल के साथ सौदा कर सकते हैं:

def multiply (x, y): 
    return x * y 

operands = (2, 4) 
multiply(*operands) 

8

डी स्काला के साथ एक ही oing:

def multiply(x:Int, y:Int) = { 
    x * y; 
} 

val operands = (2, 4) 
multiply (operands : _*) 

असफल हो जायेगी:

not enough arguments for method multiply: (x: Int, y: Int)Int.
Unspecified value parameter y.

लेकिन यह स्केला के साथ एक ही प्राप्त करने के लिए संभव है:

def multiply(x:Int, y:Int) = { 
    x*y; 
} 

val operands = (2, 4) 
multiply _ tupled operands 

Lorrin Nelson के अनुसार यह है कि यह कैसे काम करता है:

The first part, f _, is the syntax for a partially applied function in which none of the arguments have been specified. This works as a mechanism to get a hold of the function object. tupled returns a new function which of arity-1 that takes a single arity-n tuple.

बारे में अन्य पठन:

• stackoverflow.com - scala tuple unpacking