जब आप कोष्ठक, बिंदु, ब्रेसिज़, = (कार्य), आदि को छोड़ सकते हैं, तो इसके लिए सटीक नियम क्या हैं?

Question

जब आप छोड़ना (छोड़ना) कोष्ठक, बिंदु, ब्रेसिज़, = (कार्य), आदि के लिए सटीक नियम क्या हैं?

उदाहरण के लिए,

(service.findAllPresentations.get.first.votes.size) must be equalTo(2).

• service मेरी वस्तु है
• def findAllPresentations: Option[List[Presentation]]
• votes रिटर्न List[Vote]
• चाहिए और हो चश्मा के दोनों कार्य हैं

मैं क्यों नहीं जा सकता:

(service findAllPresentations get first votes size) must be equalTo(2)

?

संकलक त्रुटि है:

"RestServicesSpecTest.this.service.findAllPresentations का प्रकार विकल्प [सूची [com.sharca.Presentation]] पैरामीटर नहीं लेता है"

ऐसा क्यों लगता है कि मैं एक पैरामीटर में पारित करने की कोशिश कर रहा हूं? मुझे प्रत्येक विधि कॉल के लिए डॉट्स का उपयोग क्यों करना चाहिए?

(service.findAllPresentations get first votes size)बराबर क्यों होना चाहिए (2) परिणाम में:

"नहीं मिला: पहले मूल्य"

फिर भी, "होना चाहिए 2 के बराबर होना चाहिए" बराबर (service.findAllPresentations.get.first.votes.size)होना चाहिए 2, यानी, विधि chaining ठीक काम करता है? - वस्तु श्रृंखला श्रंखला श्रंखला param t।

मैंने स्काला पुस्तक और वेबसाइट के माध्यम से देखा है और वास्तव में एक व्यापक स्पष्टीकरण नहीं पा सकता है।

क्या यह वास्तव में है, जैसा कि रोब एच स्टैक ओवरफ्लो प्रश्न में बताते हैं कि मैं स्काला में कौन से पात्रों को छोड़ सकता हूं? , कि 'को छोड़ने के लिए एकमात्र वैध उपयोग-मामला है।' "ऑपरेंड ऑपरेटर ऑपरेंड" स्टाइल ऑपरेशंस के लिए है, न कि मेथड चेनिंग के लिए?

Answer 1

लगता है आप जवाब पर लड़खड़ा गए हैं। वैसे भी, मैं इसे स्पष्ट करने की कोशिश करूँगा।

उपसर्ग, इन्फिक्स और पोस्टफ़िक्स नोटेशन - तथाकथित ऑपरेटर नोटेशन का उपयोग करते समय आप डॉट को छोड़ सकते हैं । ऑपरेटर नोटेशन का उपयोग करते समय, और उसके बाद ही, आप कोष्ठक को छोड़ सकते हैं यदि विधि में दो पैरामीटर से कम है।

अब, ऑपरेटर नोटेशन पद्धति-कॉल के लिए एक संकेतन है , जिसका अर्थ है कि इसका उपयोग उस ऑब्जेक्ट की अनुपस्थिति में नहीं किया जा सकता है जिसे कॉल किया जा रहा है।

मैं संक्षेप में नोटेशन का विस्तार करूँगा।

उपसर्ग:

केवल ~, !, +और -उपसर्ग अंकन में इस्तेमाल किया जा सकता। यह वह संकेतन है जिसका उपयोग आप लिखते समय !flagया कर रहे हैं val liability = -debt।

इन्फ़िक्स:

यह वह संकेतन है जहाँ विधि किसी वस्तु के बीच दिखाई देती है और यह पैरामीटर है। अंकगणित संचालक सभी यहां फिट होते हैं।

उपसर्ग (प्रत्यय):

उस नोटेशन का उपयोग तब किया जाता है जब विधि किसी ऑब्जेक्ट का अनुसरण करती है और कोई पैरामीटर नहीं प्राप्त करती है । उदाहरण के लिए, आप लिख सकते हैं list tail, और यह उपसर्ग संकेतन है।

आप समस्या के बिना कॉल कर सकते हैं infix संकेतन कॉल कर सकते हैं, जब तक कि कोई विधि करी न हो। उदाहरण के लिए, मुझे निम्नलिखित शैली का उपयोग करना पसंद है:

(list
 filter (...)
 map (...)
 mkString ", "
)

यह वही बात है:

list filter (...) map (...) mkString ", "

अब, मैं यहाँ कोष्ठक का उपयोग क्यों कर रहा हूँ, यदि फ़िल्टर और मानचित्र एकल पैरामीटर लेते हैं? यह इसलिए है क्योंकि मैं उनके लिए अनाम कार्य कर रहा हूं। मैं infix शैली के साथ अनाम फ़ंक्शन परिभाषाओं को नहीं मिला सकता क्योंकि मुझे अपने अनाम फ़ंक्शन के अंत के लिए एक सीमा की आवश्यकता है। साथ ही, अनाम फ़ंक्शन की पैरामीटर परिभाषा को इन्फिक्स विधि के अंतिम पैरामीटर के रूप में व्याख्या की जा सकती है।

आप कई मापदंडों के साथ infix का उपयोग कर सकते हैं:

string substring (start, end) map (_ toInt) mkString ("<", ", ", ">")

करी कार्यों को इन्फिक्स अंकन के साथ उपयोग करना कठिन है। तह कार्य उस का एक स्पष्ट उदाहरण हैं:

(0 /: list) ((cnt, string) => cnt + string.size)
(list foldLeft 0) ((cnt, string) => cnt + string.size)

आपको इन्फिक्स कॉल के बाहर कोष्ठक का उपयोग करने की आवश्यकता है। मुझे यकीन नहीं है कि यहाँ खेलने के सटीक नियम हैं।

अब, पोस्टफ़िक्स के बारे में बात करते हैं। पोस्टफ़िक्स का उपयोग करना कठिन हो सकता है, क्योंकि किसी अभिव्यक्ति के अंत को छोड़कर कहीं भी इसका उपयोग नहीं किया जा सकता है । उदाहरण के लिए, आप निम्न कार्य नहीं कर सकते:

 list tail map (...)

क्योंकि अभिव्यक्ति के अंत में पूंछ दिखाई नहीं देती है। आप ऐसा नहीं कर सकते:

 list tail length

आप अभिव्यक्तियों के अंत को चिह्नित करने के लिए कोष्ठक का उपयोग करके infix संकेतन का उपयोग कर सकते हैं:

 (list tail) map (...)
 (list tail) length

ध्यान दें कि पोस्टफ़िक्स नोटेशन को हतोत्साहित किया जाता है क्योंकि यह असुरक्षित हो सकता है ।

मुझे उम्मीद है कि इससे सभी संदेह दूर हो गए हैं। यदि नहीं, तो बस एक टिप्पणी छोड़ दें और मैं देखूंगा कि मैं इसे सुधारने के लिए क्या कर सकता हूं।

Comments

आह, इसलिए आप कह रहे हैं कि मेरे कथन में: (((((((realService findAllPresentations) प्राप्त करें) पहले) वोट) आकार) बराबर होना चाहिए 2 - पहले, वोट और आकार सभी पोस्टफ़िक्स ऑपरेटर हैं, क्योंकि कोई पैरामीटर नहीं है ? इसलिए मुझे आश्चर्य है कि क्या होना चाहिए, और बराबर होना चाहिए ...

— एंटनी स्टब्स ने

मैं कुछ भी नहीं कह रहा हूँ, हालाँकि मुझे पूरा यकीन है कि ऐसा ही होना चाहिए। :-) "होना" शायद सिंटैक्स प्रीटरियर बनाने के लिए एक सहायक वस्तु है। या, विशेष रूप से, "चाहिए" के साथ infix संकेतन के उपयोग को सक्षम करने के लिए।

— डैनियल सी। सोबरल जूल

अच्छी तरह से मिलता है Option.get, First is list.first, वोट एक केस क्लास प्रॉपर्टी है और साइज़ list.size है। तुम अब क्या सोचते हो?

— एंटनी स्टबब्स 13

आह हाँ - यह सब इस तथ्य से प्रबलित है कि "(realService findPresentation 1) .get.id को समान होना चाहिए 1" काम करता है - जैसा कि सेवा # findPresentations (id: Int) एक ऐसा infix ऑपरेटर है जो ऐसा लगता है। कूल - मुझे लगता है कि मैं इसे अभी प्राप्त करता हूं। :)

— एंटनी स्टबब्स

Answer 2

कक्षा परिभाषाएँ:

valया varवर्ग मापदंडों से छोड़ा जा सकता है जो पैरामीटर को निजी बना देगा।

Var या val को जोड़ने से यह सार्वजनिक हो जाएगा (अर्थात, विधि अभिगमकर्ता और उत्परिवर्ती उत्पन्न होते हैं)।

{} छोड़ा जा सकता है यदि वर्ग का कोई शरीर नहीं है, अर्थात

class EmptyClass

---

कक्षा का समापन:

सामान्य पैरामीटर को छोड़ा जा सकता है यदि वे संकलक द्वारा अनुमान लगाया जा सकता है। हालाँकि, ध्यान दें, यदि आपके प्रकार मेल नहीं खाते हैं, तो टाइप पैरामीटर हमेशा अनुमानित है ताकि यह मेल खाता हो। तो प्रकार निर्दिष्ट किए बिना, आपको वह नहीं मिल सकता है जो आप अपेक्षा करते हैं - जो कि दिया गया है

class D[T](val x:T, val y:T);

यह आपको एक प्रकार की त्रुटि देगा (Int पाया गया, अपेक्षित स्ट्रिंग)

var zz = new D[String]("Hi1", 1) // type error

जबकि यह ठीक काम करता है:

var z = new D("Hi1", 1)
== D{def x: Any; def y: Any}

क्योंकि टाइप पैरामीटर, T, दो के कम से कम सामान्य सुपरटेप के रूप में अनुमानित है - कोई भी।

---

कार्य की परिभाषा:

= अगर फंक्शन यूनिट (कुछ भी नहीं) लौटाया जा सकता है।

{}फ़ंक्शन बॉडी के लिए छोड़ा जा सकता है यदि फ़ंक्शन एक एकल स्टेटमेंट है, लेकिन केवल तभी जब स्टेटमेंट एक मान लौटाता है (आपको =संकेत की आवश्यकता है ), अर्थात,

def returnAString = "Hi!"

लेकिन यह काम नहीं करता है:

def returnAString "Hi!" // Compile error - '=' expected but string literal found."

यदि यह अनुमान लगाया जा सकता है कि फ़ंक्शन का रिटर्न प्रकार छोड़ा जा सकता है (एक पुनरावर्ती विधि में इसका रिटर्न प्रकार निर्दिष्ट होना चाहिए)।

() यदि फ़ंक्शन कोई तर्क नहीं लेता है, तो उसे गिराया जा सकता है,

def endOfString {
  return "myDog".substring(2,1)
}

जो अधिवेशन उन तरीकों के लिए आरक्षित है जिनके कोई दुष्प्रभाव नहीं हैं - बाद में और अधिक।

()पैरामेंटर नाम से पास को परिभाषित करते समय वास्तव में प्रति सेशन नहीं गिराया जाता है , लेकिन यह वास्तव में काफी शब्दार्थ से अलग नोटेशन है,

def myOp(passByNameString: => String)

कहते हैं, myOp एक पास-बाय-नाम पैरामीटर लेता है, जिसके परिणामस्वरूप स्ट्रिंग (जो है, यह एक कोड ब्लॉक हो सकता है जो एक स्ट्रिंग लौटाता है) फ़ंक्शन मापदंडों के विपरीत,

def myOp(functionParam: () => String)

जो कहता myOpहै कि एक फ़ंक्शन है जिसमें शून्य पैरामीटर हैं और एक स्ट्रिंग लौटाता है।

(माइंड यू, पास-बाय-नेम पैरामीटर फंक्शंस में संकलित हो जाता है; यह सिंटैक्स को अच्छा बनाता है।)

() फ़ंक्शन पैरामीटर परिभाषा में गिराया जा सकता है यदि फ़ंक्शन केवल उदाहरण के लिए एक तर्क लेता है:

def myOp2(passByNameString:(Int) => String) { .. } // - You can drop the ()
def myOp2(passByNameString:Int => String) { .. }

लेकिन अगर यह एक से अधिक तर्क लेता है, तो आपको () शामिल होना चाहिए:

def myOp2(passByNameString:(Int, String) => String) { .. }

---

कथन:

.ऑपरेटर संकेतन का उपयोग करने के लिए गिराया जा सकता है, जिसका उपयोग केवल इन्फिक्स ऑपरेटरों (तर्कों को लेने वाले तरीकों के ऑपरेटरों) के लिए किया जा सकता है। देखें डैनियल जवाब में अधिक जानकारी के लिए।

• . उपसर्ग फ़ंक्शंस लिस्ट टेल के लिए भी छोड़ा जा सकता है

• () उपसर्ग ऑपरेटरों की सूची के लिए गिराया जा सकता है। टेल

• () के रूप में परिभाषित तरीकों के साथ इस्तेमाल नहीं किया जा सकता है:

  def aMethod = "hi!" // Missing () on method definition
  aMethod // Works
  aMethod() // Compile error when calling method

क्योंकि यह नोटेशन उन तरीकों के लिए कन्वेंशन द्वारा आरक्षित है, जिनका कोई साइड इफेक्ट नहीं है, जैसे कि लिस्ट # टेल (यानी बिना साइड इफेक्ट के किसी फंक्शन का इनवॉइस का मतलब है कि फंक्शन का कोई ऑब्जर्वेबल इफेक्ट नहीं है, सिवाय इसके रिटर्न वैल्यू के)।

• () एक तर्क में पास होने पर ऑपरेटर संकेतन के लिए छोड़ा जा सकता है

• () पोस्टफ़िक्स ऑपरेटरों का उपयोग करने की आवश्यकता हो सकती है जो एक बयान के अंत में नहीं हैं

• () नेस्टेड स्टेटमेंट, अनाम फ़ंक्शंस के सिरों या एक से अधिक पैरामीटर लेने वाले ऑपरेटरों के लिए आवश्यक हो सकता है

एक फ़ंक्शन को कॉल करते समय जो एक फ़ंक्शन लेता है, आप आंतरिक फ़ंक्शन परिभाषा से () को छोड़ नहीं सकते, उदाहरण के लिए:

def myOp3(paramFunc0:() => String) {
    println(paramFunc0)
}
myOp3(() => "myop3") // Works
myOp3(=> "myop3") // Doesn't work

किसी फ़ंक्शन को जब एक उप-नाम पैरामीटर लेता है, तो आप तर्क को पैरामीटर-कम अनाम फ़ंक्शन के रूप में निर्दिष्ट नहीं कर सकते। उदाहरण के लिए, दिया गया:

def myOp2(passByNameString:Int => String) {
  println(passByNameString)
}

आपको इसे कॉल करना होगा:

myOp("myop3")

या

myOp({
  val source = sourceProvider.source
  val p = myObject.findNameFromSource(source)
  p
})

लेकिन नहीं:

myOp(() => "myop3") // Doesn't work

IMO, रिटर्न प्रकारों को छोड़ने का अधिक उपयोग कोड को फिर से उपयोग करने के लिए हानिकारक हो सकता है। कोड में स्पष्ट जानकारी की कमी के कारण कम पठनीयता के अच्छे उदाहरण के लिए विनिर्देश देखें। अप्रत्यक्ष के स्तरों की संख्या वास्तव में यह पता लगाने के लिए कि चर का प्रकार क्या हो सकता है। उम्मीद है कि बेहतर उपकरण इस समस्या को हल कर सकते हैं और हमारे कोड को संक्षिप्त रख सकते हैं।

_{(ठीक है, एक और अधिक पूर्ण, संक्षिप्त उत्तर संकलित करने के लिए (यदि मैंने कुछ भी याद किया है, या कुछ गलत / गलत टिप्पणी दी है), तो मैंने उत्तर की शुरुआत में जोड़ा है। कृपया ध्यान दें कि यह कोई भाषा नहीं है। विनिर्देश, इसलिए मैं इसे अकादमिक रूप से सही बनाने की कोशिश नहीं कर रहा हूं - केवल संदर्भ कार्ड की तरह।)}

Comments

मैं रो रहा हूँ। यह क्या है।

— Profpatsch

Answer 3

विभिन्न परिस्थितियों में जानकारी देने वाले उद्धरणों का संग्रह ...

व्यक्तिगत रूप से, मुझे लगा कि विनिर्देशन में कुछ और होगा। मुझे यकीन है कि वहाँ होना चाहिए, मैं सिर्फ सही शब्दों के लिए नहीं खोज रहा हूँ ...

हालाँकि, कुछ सूत्र हैं, और मैंने उन्हें एक साथ एकत्र किया है, लेकिन वास्तव में पूर्ण / व्यापक / समझने योग्य कुछ भी नहीं है / जो मुझे उपरोक्त समस्याओं की व्याख्या करता है::

"यदि किसी विधि निकाय में एक से अधिक अभिव्यक्ति हैं, तो आपको इसे घुंघराले ब्रेसिज़ {…} के साथ घेरना होगा। यदि विधि बॉडी में केवल एक अभिव्यक्ति है, तो आप ब्रेसिज़ को छोड़ सकते हैं।"

से अध्याय 2, "प्रकार कम, अधिक कार्य करें", की स्काला प्रोग्रामिंग :

"ऊपरी विधि का शरीर बराबर चिह्न '=' के बाद आता है। एक बराबर चिन्ह क्यों? जावा में जैसा कि केवल घुंघराले ब्रेसिज़ {…} क्यों नहीं? क्योंकि अर्धविराम, फ़ंक्शन रिटर्न प्रकार, विधि तर्क सूची, और यहां तक ​​कि घुंघराले ब्रेसिज़? कभी-कभी छोड़ दिया जाता है, एक बराबर चिह्न का उपयोग करना कई संभावित पार्सिंग अस्पष्टताओं को रोकता है। एक समान चिह्न का उपयोग करना हमें यह भी याद दिलाता है कि फ़ंक्शन भी स्काला में मान हैं, जो स्कैला के कार्यात्मक प्रोग्रामिंग के समर्थन के अनुरूप है, अध्याय 8 में अधिक विस्तार से वर्णित, कार्यात्मक प्रोग्रामिंग। स्काला। "

से , की: अध्याय 1, "स्काला का परिचय शून्य साठ करने के लिए" स्काला प्रोग्रामिंग :

"बिना कोष्ठक के बिना किसी पैरामीटर के साथ एक फ़ंक्शन घोषित किया जा सकता है, जिस स्थिति में इसे बिना किसी कोष्ठक के साथ बुलाया जाना चाहिए। यह यूनिफ़ॉर्म एक्सेस प्रिंसिपल के लिए समर्थन प्रदान करता है, जैसे कि कॉलर को पता नहीं है कि प्रतीक एक चर है या कोई फ़ंक्शन नहीं है मापदंडों।

फ़ंक्शन बॉडी "=" से पहले होती है यदि यह मान लौटाता है (यानी रिटर्न प्रकार यूनिट के अलावा कुछ और है), लेकिन रिटर्न प्रकार और "=" को छोड़ा जा सकता है जब टाइप यूनिट (यानी यह एक प्रक्रिया की तरह दिखता है) एक समारोह के विपरीत)।

शरीर के चारों ओर ब्रेस की आवश्यकता नहीं है (यदि शरीर एक एकल अभिव्यक्ति है); अधिक सटीक रूप से, एक फ़ंक्शन का शरीर सिर्फ एक अभिव्यक्ति है, और कई हिस्सों के साथ किसी भी अभिव्यक्ति को ब्रेसिज़ में संलग्न किया जाना चाहिए (एक भाग के साथ एक अभिव्यक्ति वैकल्पिक रूप से ब्रेसिज़ में संलग्न हो सकती है)। "

"शून्य या एक तर्क के साथ कार्य को डॉट और कोष्ठक के बिना कहा जा सकता है। लेकिन किसी भी अभिव्यक्ति के चारों ओर कोष्ठक हो सकते हैं, इसलिए आप डॉट को छोड़ सकते हैं और फिर भी कोष्ठक का उपयोग कर सकते हैं।

और चूंकि आप ब्रेसिज़ का उपयोग कर सकते हैं कहीं भी आप कोष्ठक का उपयोग कर सकते हैं, आप डॉट को छोड़ सकते हैं और ब्रेसिज़ में डाल सकते हैं, जिसमें कई कथन हो सकते हैं।

बिना किसी तर्क के कार्य को बिना कोष्ठकों के कहा जा सकता है। उदाहरण के लिए, स्ट्रिंग पर लंबाई () फ़ंक्शन को "एबीसी" के रूप में आमंत्रित किया जा सकता है। "एबीसी" .length () के बजाय। यदि फ़ंक्शन कोष्ठक के बिना परिभाषित एक स्काला फ़ंक्शन है, तो फ़ंक्शन को कोष्ठक के बिना बुलाया जाना चाहिए।

अधिवेशन के द्वारा, बिना किसी तर्क के कार्य जिनके साइड इफेक्ट होते हैं, जैसे कि प्रिंटलाइन, कोष्ठक के साथ कहा जाता है; बिना साइड इफेक्ट्स वालों को बिना कोष्ठकों के कहा जाता है। "

ब्लॉग पोस्ट स्काला सिंटेक्स प्राइमर से :

"एक प्रक्रिया परिभाषा एक फ़ंक्शन परिभाषा है जहां परिणाम प्रकार और बराबर चिह्न छोड़ा जाता है; इसकी परिभाषित अभिव्यक्ति एक ब्लॉक होनी चाहिए। उदाहरण के लिए, def f (ps) {आंकड़े}, def (ps) के बराबर है: Unit = {आंकड़े }।

उदाहरण ४.२.३ यहाँ एक घोषणा और एक डी है? एक प्रक्रिया का नाम लिखें:

trait Writer {
    def write(str: String)
}
object Terminal extends Writer {
    def write(str: String) { System.out.println(str) }
}

उपरोक्त कोड अंतर्निहित रूप से निम्नलिखित कोड को पूरा किया गया है:

trait Writer {
    def write(str: String): Unit
}
object Terminal extends Writer {
    def write(str: String): Unit = { System.out.println(str) }
}"

भाषा विनिर्देश से:

"उन तरीकों के साथ जो केवल एक पैरामीटर लेते हैं, स्काला डेवलपर को एक स्थान के साथ बदलने और कोष्ठकों को छोड़ने की अनुमति देता है, जो हमारे सम्मिलन ऑपरेटर उदाहरण में दिखाए गए ऑपरेटर सिंटैक्स को सक्षम करता है। इस सिंटैक्स का उपयोग स्केला एपीआई में अन्य स्थानों पर किया जाता है, जैसे। निर्माण उदाहरण के रूप में:

val firstTen:Range = 0 to 9

यहाँ फिर से, (इंट) एक वेनिला पद्धति है जिसे एक कक्षा के अंदर घोषित किया गया है (यहाँ वास्तव में कुछ और निहितार्थ रूपांतरण हैं, लेकिन आपको बहाव मिलता है)। "

जावा शरणार्थी भाग 6 के लिए स्काला से : जावा से अधिक :

"अब, जब आप" मी 0 "की कोशिश करते हैं, तो स्केला इसे एक वैध ऑपरेटर नहीं होने के आधार पर त्याग देता है, (वैध;) - और +) यह वैध वस्तु नहीं है। यह एक फ़ंक्शन है, एक विधि नहीं है, और सभी फ़ंक्शन ऑब्जेक्ट हैं।

जैसा कि "0" एक मान्य स्काला पहचानकर्ता नहीं है, यह न तो एक इनफ़िक्स और न ही पोस्टफ़िक्स ऑपरेटर हो सकता है। इसलिए, स्काला ने शिकायत की कि यह ";" - जो दो (लगभग) वैध अभिव्यक्तियों को अलग करेगा: "m" और "0"। यदि आप इसे सम्मिलित करते हैं, तो यह शिकायत करेगा कि मी को या तो एक तर्क की आवश्यकता है, या, इसे विफल करते हुए, एक "_" इसे आंशिक रूप से लागू फ़ंक्शन में बदलने के लिए। "

"मेरा मानना ​​है कि ऑपरेटर सिंटैक्स शैली केवल तभी काम करती है जब आपको बाईं ओर एक स्पष्ट ऑब्जेक्ट मिला हो। वाक्यविन्यास का उद्देश्य आपको" ऑपरेंड ऑपरेटर ओपेरेंड "शैली संचालन को स्वाभाविक रूप से व्यक्त करने देना है।"

मैं स्काला में किन पात्रों को छोड़ सकता हूं?

लेकिन जो मुझे भ्रमित करता है वह है यह उद्धरण:

"विधि कॉल प्राप्त करने के लिए एक ऑब्जेक्ट होने की आवश्यकता है। उदाहरण के लिए, आप" Println "हैलो वर्ल्ड!" नहीं कर सकते हैं क्योंकि "println को ऑब्जेक्ट प्राप्तकर्ता की आवश्यकता होती है। आप कर सकते हैं "कंसोल Println" हैलो वर्ल्ड! "" जो जरूरत को पूरा करता है। "

के रूप में जहाँ तक मैं देख सकता है, वहाँ है कॉल प्राप्त करने के लिए एक वस्तु ...

Comments

ठीक है, इसलिए कुछ सुराग और वाह पाने के लिए चश्मा स्रोत पढ़ने की कोशिश की। यह जादू कोड के साथ समस्याओं का एक बड़ा उदाहरण है - बहुत सारे मिश्रण, प्रकार का अनुमान और अंतर्निहित रूपांतरण और अंतर्निहित पैरामीटर। अंदर से बाहर से समझना इतना कठिन है! उस तरह के बड़े पुस्तकालयों के लिए, बेहतर टूलींग कुछ चमत्कार कर सकता है ... एक दिन ...

— एंटनी स्टबब्स

Answer 4

मुझे अंगूठे के इस नियम का पालन करना आसान लगता है: विधियों और मापदंडों के बीच वैकल्पिक स्थानों में। अपने उदाहरण में, के (service.findAllPresentations.get.first.votes.size) must be equalTo(2)रूप में पर्स (service.findAllPresentations.get.first.votes.size).must(be)(equalTo(2))। ध्यान दें कि 2 के आसपास कोष्ठक रिक्त स्थान की तुलना में अधिक समरूपता रखते हैं। डॉट्स में भी उच्च समरूपता होती है, इसलिए (service.findAllPresentations.get.first.votes.size) must be.equalTo(2)यह पार्स होगा (service.findAllPresentations.get.first.votes.size).must(be.equalTo(2))।

service findAllPresentations get first votes size must be equalTo 2पर्स के रूप में service.findAllPresentations(get).first(votes).size(must).be(equalTo).2।

Answer 5

दरअसल, दूसरे पढ़ने पर, शायद यह कुंजी है:

तरीकों के साथ जो केवल एक ही पैरामीटर लेते हैं, स्काला डेवलपर को बदलने की अनुमति देता है। एक स्थान के साथ और कोष्ठकों को छोड़ दें

जैसा कि ब्लॉग पोस्ट पर बताया गया है: http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-6 ।

तो शायद यह वास्तव में एक बहुत ही सख्त "सिंटेक्स शुगर" है जो केवल उसी जगह काम करता है जहां आप एक ऑब्जेक्ट पर प्रभावी ढंग से कॉल कर रहे हैं , जो एक पैरामीटर लेता है । जैसे

1 + 2
1.+(2)

और कुछ नहीं।

यह प्रश्न में मेरे उदाहरणों की व्याख्या करेगा।

लेकिन जैसा कि मैंने कहा, अगर कोई यह बता सकता है कि भाषा में यह कहाँ निर्दिष्ट किया गया है, तो इसकी बहुत प्रशंसा होगी।

ठीक है, #scala से कुछ अच्छे साथी (paulp_) ने इंगित किया है कि भाषा में यह जानकारी कहाँ है:

६.१२.३: पूर्वक्रिया और संचालकों की सहानुभूति अभिव्यक्ति के कुछ हिस्सों के समूहन को निम्नानुसार निर्धारित करती है।

• यदि एक अभिव्यक्ति में कई इन्फिक्स ऑपरेशन होते हैं, तो उच्च पूर्वता वाले ऑपरेटर कम पूर्वता वाले ऑपरेटरों की तुलना में अधिक निकटता से बांधते हैं।
• अगर वहाँ लगातार infix संचालन e0 op1 e1 op2 हैं। । । ऑपरेटर्स op1 के साथ .opn एन। । । , एक ही मिसाल के रूप में, फिर इन सभी संचालकों की समान संगति होनी चाहिए। यदि सभी ऑपरेटर बाएं-सहयोगी हैं, तो अनुक्रम को (।।। (E0 op1 e1) 2) के रूप में व्याख्या की जाती है।) opn en। अन्यथा, यदि सभी ऑपरेटर सही हैं, अनुक्रम e0 op1 (e1 op2 (.opn en)) के रूप में व्याख्या की गई है।)।
• पोस्टफ़िक्स ऑपरेटरों की हमेशा इन्फिक्स ऑपरेटरों की तुलना में कम पूर्वता होती है। Eg e1 op1 e2 op2 हमेशा (e1 op1 e2) op2 के बराबर होता है।

बाएं-सहयोगी संचालक के दाहिने हाथ में कोष्ठक में संलग्न कई तर्क शामिल हो सकते हैं, जैसे e op (e1।,।, En)। इस अभिव्यक्ति को तब e.op (e1,।, En) के रूप में व्याख्या की जाती है।

एक बाएं-साहचर्य बाइनरी ऑपरेशन e1 op e2 को e1.op (e2) के रूप में व्याख्या किया गया है। यदि op सही है, तो एक ही ऑपरेशन को {val x = e1; e2.op (x)}, जहां x एक ताजा नाम है।

हम्म - मेरे लिए यह वह नहीं है जो मैं देख रहा हूँ या मैं इसे नहीं समझता;)

Comments

हम्म, भ्रम को और बढ़ाने के लिए, यह भी मान्य है: (((((realService findAllPresentations) पहले प्राप्त करें) वोट) आकार) बराबर होना चाहिए 2, लेकिन नहीं अगर मैं उन पैतृक जोड़े में से किसी को हटा देता हूं ...

— एंटनी जुबां

Answer 6

कोई भी नहीं है। आपको फ़ंक्शन के साइड-इफेक्ट होने या न होने के बारे में सलाह प्राप्त होगी। यह फर्जी है। सुधार स्कैला द्वारा अनुमत उचित सीमा तक साइड-इफेक्ट्स का उपयोग नहीं करना है। इस हद तक कि यह नहीं हो सकता है, तो सभी दांव बंद हैं। सभी दांव। कोष्ठक का उपयोग करना "सभी" सेट का एक तत्व है और यह बहुत ही अच्छा है। एक बार सभी दांव बंद होने के बाद यह कोई मूल्य प्रदान नहीं करता है।

यह सलाह अनिवार्य रूप से एक प्रभाव प्रणाली पर एक प्रयास है जो विफल हो जाता है (इसके साथ भ्रमित नहीं होना चाहिए: अन्य प्रभाव प्रणालियों की तुलना में कम उपयोगी नहीं है)।

साइड-इफ़ेक्ट न करने की कोशिश करें। उसके बाद, स्वीकार करें कि सभी दांव बंद हैं। एक प्रभाव प्रणाली के लिए एक वास्तविक तथ्य संकेतन संकेतन के पीछे छिपाना और नुकसान पहुंचा सकता है।

Comments

ठीक है, लेकिन यह समस्या है जब आप एक संकर OO / कार्यात्मक भाषा के साथ काम कर रहे हैं? किसी भी व्यावहारिक उदाहरण में आप साइड इफेक्ट फ़ंक्शंस करना चाहते हैं ... क्या आप हमें "प्रभाव प्रणालियों" के बारे में कुछ जानकारी दे सकते हैं? मुझे लगता है कि अधिक बिंदु बिंदु है "बिना कोष्ठक के बिना किसी पैरामीटर के साथ एक फ़ंक्शन घोषित किया जा सकता है, जिस स्थिति में इसे बिना किसी कोष्ठक के साथ बुलाया जाना चाहिए। यह यूनिफ़ॉर्म एक्सेस सिद्धांत के लिए समर्थन प्रदान करता है, जैसे कि कॉलर को पता नहीं है कि क्या है प्रतीक एक चर या फ़ंक्शन है जिसमें कोई पैरामीटर नहीं है। "

— एंटनी स्टबब्स