Scala | Sealed Trait

Sealed provides exhaustive checking for our application. Exhaustive checking allows to check that all members of a sealed trait must be declared in the same file as of the source file. That means that all the possible known members of a trait that must be included are known by the compiler in advance. So this gives us advantage to prevent mistakes in our code. 

Syntax :

sealed trait X
class A extends X
class B extends X
class C extends X

Exhaustive checking is mostly used in type / pattern matching in scala. Let’s say we have a sealed trait X and classes that extends trait X. On matching sub-types of trait X we have to make sure that we inclusion of all known sub-types is a must. Below method would give us a warning. Though we would get the correct output, but this may could be lead to unexpected runtime crashes in our application. 

Warning: match may not be exhaustive

def obj(item: X) = item match {
   case A => //
   case B => //
}

Correct implementation would be like- 

def obj(item: X) = item match{
   case A => //
   case B => //
   case C => //
   or 
   case _ => //for covering all the remaining cases
}

Let us take a view on below program in file saves as language.scala:- 

Example :

Scala

// Scala Program that illustrates sealed trait
// language.scala
sealed trait Geeks
{
    val article="not done"
}

// Class extends trait
class Scala extends Geeks
{
    override val article = "scala article"
}

// Class extends trait
class Java extends Geeks
{
    override val article = "java article"
}

// Class extends trait
class Csharp extends Geeks
{
    override val article = "csharp article"
}

// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
        val s = new Scala
        val j = new Java
        val c = new Csharp
        println(checkArticle(s))
        println(checkArticle(j))
        println(checkArticle(c))
    }

    // Defined function
    def checkArticle(Article: Geeks): String = Article match
    {
        case s: Scala  => s.article
        case j: Java   => j.article
        case c: Csharp => c.article
        //exclusion of <strong>line 45</strong> would lead to warning
    }
}

Output :

scala article
java article
csharp article

some important points

• Sub-types of a trait are known in advance- Not including any of the sub-type of sealed class C in pattern match would give us warning. Such a warning tells you that there’s a risk your code might produce a Match Error exception because some possible patterns are not handled. The warning points to a potential source of run-time faults, so it is usually a welcome help in getting your program right. 
  
• Sealed traits can only extend in the same source file as of sub-types- In above example, we have another class python in another scala file. Importing the trait geeks from language.scala we would get error message as below.

illegal inheritance from sealed trait bag

import geeks
class python extends geeks{
    val article="python article";
}

• Sealed class is also mostly used in enums– Preventing illegal inheritance and using all the sub-type so to avoid exhaustive matching warnings. 
  Example :

Scala

// Scala Program that illustrates sealed trait
// By using Enumeration
sealed trait card extends Enumeration

// Class extends trait
case object CLUB extends card

// Class extends trait
case object HEART extends card

// Class extends trait
case object DIAMOND extends card

// Class extends trait
case object SPADE extends card

// Creating object
object obj1
{
    // Main method
    def main(args: Array[String])
    {
        val card1 = HEART
        val card2 = CLUB
        val card3 = SPADE
        val card4 = DIAMOND
        println(checkcard(card1))
        println(checkcard(card2))
        println(checkcard(card3))
        println(checkcard(card4))
    }

    // Defined function
    def checkcard(x: card): String = x match
    {

        case HEART   =>"heart"
        case CLUB    =>"club"
        case SPADE   =>"spade"
        case DIAMOND =>"diamond"
    }
}

Output :

heart
club
spade
diamond