स्कैला: क्या आप ब्रांड्स के बिना अभिव्यक्ति में "foo match {bar}" का उपयोग कर सकते हैं?

Question

यहां कोष्ठक की आवश्यकता क्यों है? क्या मुझे कुछ प्राथमिकता नियम पता होना चाहिए?

scala> 'x' match { case _ => 1 } + 1 
<console>:1: error: ';' expected but identifier found. 
     'x' match { case _ => 1 } + 1 
           ^

scala> ('x' match { case _ => 1 }) + 1 
res2: Int = 2 

धन्यवाद!

Answer 1

एक मिलान अभिव्यक्ति को सरल अभिव्यक्ति के रूप में नहीं माना जाता है। यहां एक समान उदाहरण दिया गया है:

scala> val foo = "bar" + if(3 < 5) 3 else 5 // does not compile 
scala> val foo = "bar" + (if(3 < 5) 3 else 5) // does compile 

स्पष्ट रूप से आप जहां चाहें जटिल अभिव्यक्तियां नहीं लिख सकते हैं। मुझे नहीं पता कि क्यों और उम्मीद है कि इस विषय के अधिक ज्ञान वाले व्यक्ति आपको बेहतर उत्तर देंगे।

Answer 2

जैसा कि एग्जिस्टेल कहते हैं, एक मैच को सरल अभिव्यक्ति के रूप में नहीं माना जाता है, न ही एक कथन है, इसलिए आपको अभिव्यक्ति को कोष्ठक से घिरा होना चाहिए। The Scala Language Specification से, 6 अभिव्यक्तियां, पी 73, मैच एक एक्सप्र है, जैसा कि एक है। केवल SimpleExpr + ऑपरेटर के दोनों ओर स्वीकार किए जाते हैं।

एक एक्स्प्रेस को एक SimpleExpr में परिवर्तित करने के लिए, आपको इसे() से घिरा करना होगा।

संपूर्णता के लिए कॉपी किया गया:

Expr ::= (Bindings | id | ‘_’) ‘=>’ Expr 
    | Expr1 
Expr1 ::= ‘if’ ‘(’ Expr ‘)’ {nl} Expr [[semi] else Expr] 
    | ‘while’ ‘(’ Expr ‘)’ {nl} Expr 
    | ‘try’ ‘{’ Block ‘}’ [‘catch’ ‘{’ CaseClauses ‘}’] [‘finally’ Expr] 
    | ‘do’ Expr [semi] ‘while’ ‘(’ Expr ’)’ 
    | ‘for’ (‘(’ Enumerators ‘)’ | ‘{’ Enumerators ‘}’) {nl} [‘yield’] Expr 
    | ‘throw’ Expr 
    | ‘return’ [Expr] 
    | [SimpleExpr ‘.’] id ‘=’ Expr 
    | SimpleExpr1 ArgumentExprs ‘=’ Expr 
    | PostfixExpr 
    | PostfixExpr Ascription 
    | PostfixExpr ‘match’ ‘{’ CaseClauses ‘}’ 
PostfixExpr ::= InfixExpr [id [nl]] 
InfixExpr ::= PrefixExpr 
    | InfixExpr id [nl] InfixExpr 
PrefixExpr ::= [‘-’ | ‘+’ | ‘~’ | ‘!’] SimpleExpr 
SimpleExpr ::= ‘new’ (ClassTemplate | TemplateBody) 
    | BlockExpr 
    | SimpleExpr1 [‘_’] 
SimpleExpr1 ::= Literal 
    | Path 
    | ‘_’ 
    | ‘(’ [Exprs] ‘)’ 
    | SimpleExpr ‘.’ id s 
    | SimpleExpr TypeArgs 
    | SimpleExpr1 ArgumentExprs 
    | XmlExpr 
Exprs ::= Expr {‘,’ Expr} 
BlockExpr ::= ‘{’ CaseClauses ‘}’ 
    | ‘{’ Block ‘}’ 
Block ::= {BlockStat semi} [ResultExpr] 
ResultExpr ::= Expr1 
    | (Bindings | ([‘implicit’] id | ‘_’) ‘:’ CompoundType) ‘=>’ Block 
Ascription ::= ‘:’ InfixType 
    | ‘:’ Annotation {Annotation} 
    | ‘:’ ‘_’ ‘*’ 

Answer 3

स्काला विनिर्देश में कुछ निरीक्षण के बाद, मुझे लगता है कि मैं इसे एक शॉट दे सकते हैं। यदि मैं गलत हूं तो कृपया मुझे सही करें।

पहले, if या match को Expr - अभिव्यक्तियों के रूप में परिभाषित किया गया है।

आप एक इन्फ़िक्स अभिव्यक्ति (दो भाव के बीच ऑपरेटर के उपयोग द्वारा परिभाषित)

बनाने के लिए हालांकि especification (खंड 3.2.8) में कहा गया कोशिश कर रहे हैं कि:

fi x ऑपरेटरों के सभी प्रकार वही प्राथमिकता है; कोष्ठक को

समूहीकरण के लिए इस्तेमाल किया जा है यह भी यह भी कहा गया है कि:

fi x संचालन t0 OP1 t1 op2 में लगातार प्रकार के अनुक्रम में। । । ओपन टीएन, सभी ऑपरेटरों op1,। । । , ओपन में सहयोगी होना चाहिए। यदि वे सभी बाएं-सहयोगी हैं, तो अनुक्रम (...। (T0 op1 t1) op2 ... के रूप में व्याख्या किया गया है।) Opn tn।

तो मेरा लेना यह है कि स्कैला को यह नहीं पता कि पहले क्या कम करना है: मैच या विधि '+' आमंत्रण।

इस answer

पर एक नजर डालें कृपया मुझे सही कर अगर मैं गलत हूँ।