स्केल में `टाइप` और` # `कीवर्ड की जांच

Question

क्या कोई बता सकता है कि type कीवर्ड और # ऑपरेटर स्केल में कैसे काम करता है और इसका उपयोग कैसे करें? कृपया उदाहरण देखें।

//Example1 
scala> type t1 = Option.type 
defined type alias t1 

//Shouldn't this work since previous example simply works? 
scala> type t2 = String.type 
<console>:7: error: type mismatch; 
found : String.type 
required: AnyRef 
     type t2 = String.type 
     ^

//lets define custom trait T 
scala> trait T 
defined trait T 

//... and obtain it's type like in Example1. 
//Shouldn't this work since previous Example1 simply works? 
scala> type t3 = T.type 
<console>:7: error: not found: value T 
     type t3 = T.type 
     ^

//Lets define some value of type T 
scala> val v4 = new T{} 
v4: T = $anon$1@5c3e8c76 

//and obtain it's type (works) 
scala> type t4 = v4.type 
defined type alias t4 

//this doesn't work 
scala> type t4_1 = (new T{}).type 
<console>:1: error: identifier expected but 'new' found. 
     type t4_1 = (new T{}).type 

//as well as this (doesn't work) 
scala> type t5 = "abc".type 
<console>:1: error: identifier expected but string literal found. 
     type t5 = "abc".type 
     ^

//but this compiles well 
scala> val v6 = "abc" 
v6: String = abc 

scala> type t6 = v6.type 
defined type alias t6 


//lets create some values of created types: 
scala> type t1 = Option.type 
defined type alias t1 

scala> val v1_1 = Some(10) 
v1_1: Some[Int] = Some(10) 

scala> type t7 = v1_1.type 
defined type alias t7 

scala> val v7:t7 = null 
v7: t7 = null 

scala> val v7_1:t7 = v1_1 
v7_1: t7 = Some(10) 

scala> val v7_2:t7 = Some(10) 
<console>:9: error: type mismatch; 
found : Some[Int] 
required: t7 
    (which expands to) v1_1.type 
     val v7_2:t7 = Some(10) 
      ^


//next let's try # operator 

scala> class X[A,B](a:A,b:B) 
defined class X 

//doesn't work 
scala> type xa = X[A,B]#A 
<console>:8: error: not found: type A 
     type xa = X[A,B]#A 
     ^
<console>:8: error: not found: type B 
     type xa = X[A,B]#A 
      ^

//but such approach works: 
scala> trait X2[C]{ 
    type A 
    type B 
    val c:C 
} 
defined trait X2 

scala> type xa2_1 = X2[String]#A 
defined type alias xa2_1 

scala> type xa2_2[M] = X2[M]#A 
defined type alias xa2_2 

Answer 1

पहले, अपने type के बारे में सवाल:

एक प्रकार घोषणा की दाहिने हाथ की ओर एक स्थिर पथ के साथ एक प्रकार का नाम हो गया है। तो एक करके अपने उदाहरण एक विकेट:

type t1 = Option.type 

t1 Optionवस्तु, नहीं Option वर्ग के प्रकार के लिए एक उपनाम है।

type t2 = String.type 

यह एक त्रुटि है क्योंकि String ऑब्जेक्ट नहीं है। त्रुटि थोड़ा अजीब है क्योंकि स्ट्रिंग एक जावा क्लास है और इसलिए विभिन्न नियमों के तहत संचालित होती है (चूंकि जावा क्लास में कभी साथी नहीं होते हैं)।

type t3 = T.type 

ditto। इस बार त्रुटि की स्पष्ट है, क्योंकि टी एक स्काला वर्ग और है तो संकलक स्पष्ट रूप से कहते हैं कि

type t4 = v4.type 

यह वैल v4 द्वारा नामित वस्तु की सिंगलटन प्रकार है "टी एक प्रकार के साथ एक वस्तु का नाम नहीं है" कर सकते हैं । यह आपके new T{} अभिव्यक्ति द्वारा बनाए गए अनाम वर्ग के किसी भी उदाहरण या यहां तक ​​कि किसी भी उदाहरण का संदर्भ नहीं देता है। यह केवलv4 और null द्वारा दर्शाए गए एक प्रकार को संदर्भित करता है, यानी वे उस प्रकार के एकमात्र अनुमत मान हैं।

type t4_1 = (new T{}).type 

यह गैर कानूनी है क्योंकि बात के होने की एक स्थिर पहचानकर्ता (मोटे तौर पर, एक पहचानकर्ता जिसका referant कभी नहीं बदल सकते हैं जब आप प्रकार ले जा रहे हैं - अगर idenfier का पूर्ण पथ केवल नाम के होते हैं पैकेज, object एस, और val एस, यह स्थिर है)।

type t5 = "abc".type 

Ditto।

type t6 = v6.type 

v6 एक स्थिर पहचानकर्ता है। t6 स्ट्रिंग के उस विशेष उदाहरण द्वारा पूरी तरह से निवास किया गया प्रकार है जिसे v6 (और null) नाम से संदर्भित किया गया है।

type v6 = v1_1.type 

फिर, एक सिंगलटन प्रकार।

val v7: t7 = null 

null तो यह विशेष वस्तु है प्रकार t7

val v7_1:t7 = v1_1 

की कोई मान्य मान है।

val v7_2:t7 = Some(10) 

लेकिन यह एक अलग वस्तु है (भले ही यह v7 को == है, यह यह करने के लिए eq नहीं है) और इसलिए इस प्रकार का सदस्य नहीं है।

अब के बारे में #

:

class X[A,B](a:A,b:B) 

A और B प्रकार पैरामीटर है। उन्हें वर्ग के बाहर संदर्भित नहीं किया जा सकता है। आप उनके बारे में private[this] दृश्यता के साथ अमूर्त प्रकार उपनामों के बारे में सोच सकते हैं, हालांकि यह बिल्कुल सटीक नहीं है।

type xa = X[A,B]#A 

तो हाँ, दिखाई नहीं दे रहा है।

type xa2_1 = X2[String]#A 

के बाद से इसA एक सार्वजनिक प्रकार उर्फ ​​को संदर्भित करता है, यह करने के लिए नाम से कक्षा के बाहर भेजा जा सकता है। ध्यान दें कि यह विशेष मामला बहुत बेकार है, क्योंकि आप इस प्रकार के बारे में बिल्कुल कुछ नहीं जानते हैं। अपने विशेषता X2 एक विधि है कि प्रकार A के मूल्यों लौटे था, तो आप

val aFromX2: xa2_1 = x2instance.methodThatReturnsAnA 

की तरह कुछ कर सकता है ..लेकिन तो आप इसके साथ कुछ और नहीं कर सका, यहां तक ​​कि यह X2[String] का एक उदाहरण है, क्योंकि वापस करने के लिए पारित इस बात की कोई गारंटी नहीं है कि दो A एस एक ही प्रकार का संदर्भ लेंगे! इस मामले में यह काम करता है

def passAroundA(x2instance: X2[String]) { 
    type x2a = x2instance.A // note dot, not # 
    val a: x2a = x2instance.methodThatReturnsAnA 
    x2instance.methodThatTakesAnA(a) 
} 

क्योंकि भले ही हम पता नहीं क्या A वास्तव में है, हम जानते हैं कि दो तरीकों का उपयोग करें: दूसरी ओर, यदि आप एक ठोस उदाहरण है, तो आप ऐसा कर सकता है एक ही प्रकार - जो भी x2instance के निर्माण पर तय किया गया था।

Answer 2

व्यावहारिक रूप से आपके प्रश्न के बारे में सब कुछ this imho absolutely essential talk में पैटर्न मिलान आदि जैसे मामलों पर समझाया गया है। मेरा सुझाव है कि आप इसे देखने के लिए समय और इसके बारे में कुछ करने का प्रयास करें। बहुत सारे स्कैला टाइप सिस्टम से संबंधित सामान वास्तव में मेरे लिए एक जादू था जब तक कि मैंने यह वीडियो नहीं देखा। मैं अपने सिस्टम के दिनों के अजीब व्यवहार को हल करने की कोशिश कर रहा हूं और अगर मैं इन चीजों से अवगत हूं तो अनुमान लगाएं।