कुछ मामलों में उच्च आदेश प्रत्यारोपण क्यों अनदेखा किया जाता है?

Question

मुझे एक अंतर्दृष्टि के बारे में एक अजीब कंपाइलर त्रुटि मिली जो वास्तव में मौजूद है लेकिन किसी कारण से नहीं मिल सका। इसलिए मैंने एक छोटा परीक्षण केस बनाया है जो रहस्यमय व्यवहार को पुन: उत्पन्न करता है।

trait Hide { 
    type T 
} 
object HideString extends Hide { 
    override type T = String 
} 
object HideBool extends Hide { 
    override type T = Boolean 
} 

सरल प्रकार के लिए असीमित लक्ष्य के रूप में उपयोग किया जाने वाला सरल प्रकार।

def id[H <: Hide, C](x : C)(implicit ev : C => H#T) : H#T = ev(x) 
def drop[H <: Hide, C](x : C)(implicit ev : C => H#T) : Int = { 
    println(ev(x)) 
    1 
} 
def idSeq[H <: Hide, C](x : Seq[C])(implicit ev : Seq[C] => Seq[H#T]) : Seq[H#T] = ev(x) 
def dropSeq[H <: Hide, C](x : Seq[C])(implicit ev : Seq[C] => Seq[H#T]) : Int = { 
    println(ev(x)) 
    1 
} 

विधियां जो लागू रूपांतरणों पर भरोसा करती हैं। यह मूल रूप से 2x2 मैट्रिक्स है। id विधियां परिवर्तित प्रकार लौटाती हैं और drop विधियां आंतरिक रूप से रूपांतरण का उपयोग करती हैं और कुछ स्थिर लौटती हैं। सामान्य तरीके सटीक रूप से परिवर्तित प्रकार पर चलती हैं और Seq विधियां अनुक्रमों पर चलती हैं।

implicit def exString(x : String) : HideString.type#T = x 
implicit def highString[F[_]](x : F[String]) : F[HideString.type#T] = x 

अंतर्निहित रूपांतरण highString से ऊपर उच्च क्रम प्रकार के साथ परिभाषित किया गया है।

ImplicitResolution.scala:98: error: No implicit view available from Seq[String] => Seq[test.implicits.HighReduction.Hide#T]. 
    val r2 = dropSeq(Seq("i", "IO")) 

निम्नलिखित मैट्रिक्स में संक्षेप किया जा सकता है कि:

|  | id | drop | 
|--------+------+------| 
| normal | pass | pass | 
| seq | pass | fail | 

मैं ठीक dropSeq विधि के लिए अंतर्निहित रूपांतरण परिभाषित उपयोग करते हैं तो

val s1 = id("sdf") 
val s2 = drop("aero") 

val r1 = idSeq(Seq("a", "bc")) 
val r2 = dropSeq(Seq("i", "IO")) 

वास्तव में रूपांतरण का उपयोग करने की कोशिश कर मुझे एक त्रुटि लाता है यह सामान्य रूप से पाया जाता है:

implicit def seqBool(x : Seq[Boolean]) : Seq[HideBool.type#T] = x 

val a1 = idSeq(Seq(true, false)) 
val a2 = dropSeq(Seq(false, true)) 

और इसके अलावा अगर मैं स्पष्ट रूप से निहित तर्क dropSeq निर्दिष्ट काम करना शुरू किया:

val r2i = dropSeq(Seq("i", "IO"))(highString[Seq] _) 

और वह अजीब बात है। highString निहित सभी आवश्यकताओं के अनुरूप है। और इसे implicit के रूप में घोषित किया गया है, इसलिए इसे कंपाइलर द्वारा पाया जाना चाहिए। और idSeq के मामले में यह वास्तव में पाया जाता है। तो, dropSeq मामले में इसे क्यों नजरअंदाज किया जाता है?

Answer 1

आपके मामले में idSeq और dropSeq के बीच एकमात्र अंतर रिटर्न प्रकार है: आपने स्कैला कंपाइलर में कुछ कोने केस मारा है जो स्कैला समुदाय को संकेत देने योग्य है।

जिसके अनुसार, अपने idSeq गलत हस्ताक्षर है: H#X निर्दिष्ट H प्रकार के लिए एक्स प्रकार मतलब यह नहीं है, बल्कि यह है कि संकलक द्वारा हल किया गया है एच (नहीं एक के किसी भी उदाहरण के लिए X, देख डैनियल Sobral स्पष्टीकरण यहाँ What does the `#` operator mean in Scala?)

क्या आप शायद क्या करना चाहते हैं एच और अपने परिणाम प्रकार है, जो आसान है अगर आप एक अधिक पठनीय हस्ताक्षर प्राप्त करने के लिए प्रकार उपनाम परिचय के बीच एक रिश्ता स्थापित करना है:

object Hide { 
    type HideAux[X] = Hide { type T = X} 
} 

आप कर सकते हैं फिर वें जैसे कोड को फिर से लिखें है:

def idSeq[B,H <: HideAux[B], C](x : Seq[C])(implicit ev : Seq[C] => Seq[B]) : Seq[B] = ev(x) 
    def dropSeq[B,H <: HideAux[B], C](x : Seq[C])(implicit ev : Seq[C] => Seq[B]) : Int = { 
    println(ev(x)) 
    1 
    } 

इस कोड संकलन, और यह भी सूचना है कि अगर आप सही तरीके सामान्य और typeclasses उपयोग करते हैं, तो आपके पास दो अलग अलग तरीकों id और idSeq की जरूरत नहीं होगी क्योंकि गतिशील व्यवहार typeclass से ही उपलब्ध कराया जा रहा है।