स्काला Seq ही उप-प्रकार

Question

का ही तत्व को स्वीकार मैं निम्नलिखित की तरह एक प्रकार पदानुक्रम है मान लिया जाये कि या तो सभी Green, लेकिन दोनों नहीं?

निम्नलिखित कोड में उदाहरण के लिए:

def process[T](colors: Seq[T]) = colors.size 

process(Seq(Red("a"), Green("g"))) 

क्या [T] इतना होना चाहिए कि ऊपर टाइप-जाँच नहीं करता है?

संपादित

मूल समस्या यह है: मैं नेस्टेड प्रश्नों के लिए एक JSON एपीआई वसीयत करने की कोशिश कर रहा हूँ। मैं निम्नलिखित डिजाइन के साथ आए हैं:

trait QueryUnit 
case class SimpleQuery(query: String, metadata: Metadata) 
case class ComplexQuery(Map[String, Seq[SimpleQuery]) 

case class API(
    query: Map[String, Seq[QueryUnit]] 
) 

मानचित्र के तत्वों, conjuctions (ands) हो जाएगा, जबकि Seq के तत्वों disjunctions (ORS) हो जाएगा। मैं ComplexQueries के साथ सरल मिश्रण नहीं करना चाहता, और मैं Seq [QueryUnit] पर पैटर्न मिलान की योजना बना रहा हूं।

Answer 1

(आंशिक रूप से this blog post from Miles Sabin के आधार पर) इस प्रयास करें:

// Your domain 
trait QueryUnit 
case class SimpleQuery(query: String, metadata: AnyRef) extends QueryUnit 
case class ComplexQuery(map: Map[String, Seq[SimpleQuery]]) extends QueryUnit 
// End of your domain 

// Something which has type parameter, so we can add QueryUnit, ... 
trait WrongArg[T] 

// Create ambiguous implicits for QueryUnit 
implicit def v0: WrongArg[QueryUnit] = ??? 
implicit def v2: WrongArg[QueryUnit] = ??? 

// And valid values for the concrete subclasses 
implicit val simpleQWrongArg: WrongArg[SimpleQuery] = new WrongArg[SimpleQuery] {} 
implicit val complexQWrongArg: WrongArg[ComplexQuery] = new WrongArg[ComplexQuery] {} 

case class API[QU <: QueryUnit](
       query: Map[String, Seq[QU]] 
    // Require an evidence that we are getting the correct type 
           )(implicit w: WrongArg[QU]) { 
} 

API/*[SimpleQuery]*/(Map("" -> Seq(SimpleQuery("", "")))) 

API/*[ComplexQuery]*/(Map("" -> Seq(ComplexQuery(Map.empty)))) 

// Fails to compile because of ambiguous implicits 
//API(Map("s" -> Seq(SimpleQuery("", "")), "c" -> Seq(ComplexQuery(Map.empty)))) 

यह (गलत नाम, कोई @implicitNotFound एनोटेशन) आदर्श नहीं है।

मूल विचार यह है कि हम बेस क्लास के लिए संदिग्ध निहितार्थ बनाते हैं, लेकिन उप-वर्गों के लिए नहीं। निहित संकल्प नियमों के कारण यह केवल उप-वर्गों के लिए संकलित होगा, लेकिन आधार वर्ग के लिए नहीं।

@annotation.implicitNotFound("Base QueryUnit is not supported, you cannot mix SimpleQuery and ComplexQuery") 
trait Handler[T] extends (T => Unit) 

object API { 
    implicit def baseQueryUnitIsNotSupported0: Handler[QueryUnit] = ??? 

    implicit def baseQueryUnitIsNotSupported1: Handler[QueryUnit] = ??? 

    implicit val simpleQWrongArg: Handler[SimpleQuery] = new Handler[SimpleQuery] { 
    override def apply(s: SimpleQuery): Unit = {} 
    } 
    implicit val complexQWrongArg: Handler[ComplexQuery] = new Handler[ComplexQuery] { 
    override def apply(s: ComplexQuery): Unit = {} 
    } 
} 

case class API[QU <: QueryUnit](query: Map[String, Seq[QU]])(
    implicit handler: Handler[QU]) { 
    // Do something with handler for each input 
} 

// Usage 

import API._ 

import scala.annotation.implicitNotFound 
API/*[SimpleQuery]*/(Map("" -> Seq(SimpleQuery("", "")))) 

API/*[ComplexQuery]*/(Map("" -> Seq(ComplexQuery(Map.empty)))) 

// Error:(56, 71) Base QueryUnit is not supported, you cannot mix SimpleQuery and ComplexQuery 
//API(Map("s" -> Seq(SimpleQuery("", "")), "c" -> Seq(ComplexQuery(Map.empty)))) 

वैकल्पिक प्रकार सीमा के साथ

और implicitly:

एक संस्करण साफ

case class API[QU <: QueryUnit: Handler](query: Map[String, Seq[QU]]) { 
    def doSomething: Unit = for {(_, vs) <- query 
     v <- vs} { 
    val handler: Handler[QU] = implicitly[Handler[QU]] 
    handler(v) 
    } 
}