Scala, method call compiles with dot, doesn't compile without -

आत्म-यातना के प्रयोजनों के लिए मैं if-elseif-else < / कोड> निर्माण ( कब -पर -पर-अन्यथा मेरे मामले में)। मजेदार बात यह है कि जिस चीज़ ने मैंने लिखा है, उसे से पहले डॉट किए बिना संकलित करता है, लेकिन , और इसके साथ संकलन करता है, और इससे पहले और डॉट किए बिना अन्यथा < code>:

 कब (गलत) {println ("& gt; & gt; ट्रू"}} .butWhen (गलत) {println ("& gt; & gt; हैलो"}} .butWhen (false) {// डॉट के बिना "बूलियन (झूठे) पैरामीटर नहीं लेता है", "अन्यथा {println (" & gt; कुछ और ")}    
 मेरी अप्रशिक्षित आंखों के लिए, दोनों  की घोषणाओं पर  और अन्यथा एक समान हैं, इसलिए ऐसा लगता है कि उन्हें वही व्यवहार करना चाहिए। इसके अलावा, जब मैं  अन्यथा  को सीधे क्लास के लिए चेन करता हूं, तो संकलन डॉट के बिना भी सफल होता है I  
 क्या आप मुझे डॉट से छुटकारा पाने में मदद कर सकते हैं? नीचे  के लिए कोड है लेकिन जब- अन्यथा :  
  
 विशेषता ButWhenTrait {def butWhen (b: बूलियन) (op3: = & gt; इकाई) : लेकिन जब def def (b: बूलियन) (op: = & gt; यूनिट) (ऑप: = & gt; इकाई) // {}}    
 ऑब्जेक्ट : ओफ़राइड def (ऑप्शन 2: = & gt; यूनिट) {op2} ओवरराइड डीईफ़ लेकिन जब (बी: बूलियन), लेकिन जब प्रॉपट्रेक्ट = {अगर (बी) {एप डेडएन्ड} और एफएलएस}}  
 वस्तु गलत है, (Op2: = & gt; इकाई) = {अगर (बी) {op2 deadEnd} else {FalseWhen}}}  
 ऑब्जेक्ट डेडएन्ड का विस्तार होता है लेकिनन्तु {ओवरराइड डीआरएफ अन्यथा (ऑप: = & gt; यूनिट) {} ओवरराइड Def लेकिन जब (बी: बूलियन) (ऑप: = & gt; इकाई) = {डेडएन्ड}}   
 
 
 त्रुटि अगली सीमाओं के कारण: प्रत्यय के लिए अंकन केवल  Arity-0  & amp; संभावित समाधान:  
  1) विभाजित कॉल द्वारा 2 ऑब्जेक्ट के लिए मेथरी एरीटी को कम करें:   Arity-1  p> 
  - नवीनीकृत (त्रुटि नियत) -   
  विशेषता ButWhenTrait {def लेकिन जब (बी: बूलियन): ExecBlock def अन्यथा (op: = & gt यूनिट) यूनिट} ExecBlock {// $ हस्तांतरण निष्पादन फ़ंक्शन डीईएफ़ $ (ऑप: = & gt; यूनिट) के लिए विधि का नाम: ButWhenTrait} ऑब्जेक्ट NextExecBlock ExecBlock विस्तारित {ऑब्जेक्ट अगली लेकिन ButWhenTrait {def butWhen (B: Boolean): ExecBlock = if (b) EndExecBlock else NextExecBlock def अन्यथा (op: = & gt; यूनिट) {op}} def $ (op: = & gt; इकाई): ButWhenTrait = next} विशेषता EmptyButWhenTrait {ऑब्जेक्ट अगली लेकिन ButWhenTrait {def अन्यथा (ओफ़) का विस्तार करता है : = & Gt; यूनिट) {} def लेकिन जब (बी: बूलियन) = एम्टीईएक्सएकब्लॉक}} ऑब्जेक्ट एंडएक्सएकब्लॉक एक्स्टीकब्लॉक को एम्टीटीबूटवेनटाइट के साथ विस्तारित करता है {def $ (op: = & gt; यूनिट): ButWhenTrait = {op; अगले}} वस्तु EmptyExecBlock EmptyButWhenTrait {def $ (op: = & gt; इकाई) के साथ ExecBlock का विस्तार करता है: जब {def} (b: बूलियन) (op: = & gt; यूनिट) लागू होता है: ButWhenTrait = if (b) उपयोग के मुकाबले EndExecBlock $ से अधिक NextExecBlock $ op}   
  
  कब (गलत) {println ("& gt; & gt; ट्रू")} लेकिन जब ( झूठे) $ {println ("& gt; & gt; हैलो"}} लेकिन जब (गलत) $ {println ("& gt; & gt; अलविदा"}} अन्यथा {println ("& gt; & gt; कुछ और")}   
   
  विशेषता ButWhenTrait {def लेकिन जब (op: ButWhenTrait):  
  2) बूलियन के लिए अंतर्निहित convesrions के साथ विधि लागू करने के उद्देश्य के साथ: (ऑप्शन: = & gt; यूनिट) {ऑप्टर}} क्लास ExecBlock (b: बूलियन) {निजी ऑब्जेक्ट का अगला विस्तार होता है, लेकिन जब ऑट्रेड निजी ऑब्जेक्ट एंड का विस्तार होता है लेकिनवेफ्टट्रेट {ओवरराइड डेफ लेकिन जब (ऑप: लेकिन वर्टेटेट) = एंड ओवरराइड डेफ अन्यथा (ऑप्शन: = & gt; यूनिट) {}} डीईफ़ लागू (ऑप: = & gt; यूनिट): लेकिनWhenTrait = if (बी) {ऑप; (ए: = & gt; इकाई): लेकिन जब प्रक्षेपण = नया ExecBlock (बी) (ऑप)} // और अंतर्निहित रूपांतरण: अंतर्निहित डीईएफ़ बॉल्सटोएक्सएसी (बी: बूलियन): उपयोग के मुकाबले ExecBlock = new ExecBlock (b)   
 उपयोग (जैसा आपकी अपेक्षा है):  
  कब (गलत) {println ("& gt; & gt; ट्रू" )} लेकिन जब (झूठे) {println ("& gt; & gt; हैलो"}} लेकिन जब (झूठे) {println ("& gt; & gt; अलविदा"}} अन्यथा {println ("& gt; & gt; कुछ और"}}