एसबीटी

Question

में गैर-संपूर्ण मैच पर संकलन विफलता करें मान लें कि मेरे पास एक बच्चे, बच्चे के साथ एक गुण, माता-पिता है।

scala> sealed trait Parent 
defined trait Parent 

scala> case object Boy extends Parent 
defined module Boy 

मैं एक समारोह लिखता हूं जो पैटर्न सीलबंद विशेषता पर मेल खाता है। मेरा f फ़ंक्शन कुल है क्योंकि केवल एक ही Parent उदाहरण है।

scala> def f(p: Parent): Boolean = p match { 
    | case Boy => true 
    | } 
f: (p: Parent)Boolean 

फिर, 2 महीने बाद, मैं Parent के Girl बच्चे जोड़ने का निर्णय लेते।

scala> case object Girl extends Parent 
defined module Girl 

और फिर f विधि को फिर से लिखें क्योंकि हम REPL का उपयोग कर रहे हैं।

scala> def f(p: Parent): Boolean = p match { 
    | case Boy => true 
    | } 
<console>:10: warning: match may not be exhaustive. 
It would fail on the following input: Girl 
     def f(p: Parent): Boolean = p match { 
           ^
f: (p: Parent)Boolean 

मैं एक गैर संपूर्ण मैच का सामना करने के लिए गए थे, तो मैं एक संकलन समय चेतावनी (जैसा कि हम यहाँ देखें) प्राप्त होगी।

हालांकि, मैं संकलन गैर-संपूर्ण मिलान पर विफल कैसे कर सकता हूं?

Answer 1

आप स्केलैक के विकल्पों में -Xfatal-warnings जोड़ सकते हैं। इस तरह किसी भी चेतावनी को एक त्रुटि के रूप में माना जाएगा।

एसबीटी में, आप प्राप्त कर सकते हैं कि साथ:

scalacOptions += "-Xfatal-warnings" 

Answer 2

शायद आप एक डिफ़ॉल्ट के मामले में पद से परिभाषित तत्वों को पकड़ने और एक आंशिक समारोह जो आप अलग से प्रबंधन कर सकते हैं करने के लिए इसे बाध्य करने के लिए डाल सकता है। फिर आंशिक "डिफ़ॉल्ट हैंडलर" के रूप में कार्य करेगा।

sealed trait Animal 
    case class Dog(name: String) extends Animal 
    case class Cat(name: String) extends Animal 

    val t: Animal = Dog("fido") 

    // updates when the trait updates 
    val partial = PartialFunction[Animal, Unit] { 
    case Dog(_) => println("default dog") 
    case Cat(_) => println("default cat") 
    case _ => throw new RuntimeException("Broken") 
    } 

    // matches that may be out of date refer to it 
    t match { 
    case Dog(_) => println("specific dog") 
    case t => partial(t) 
    } 

या शायद आप केवल आंशिक कार्यों का उपयोग करके और उन्हें एक साथ श्रृंखलाबद्ध कर सकते हैं।