Escala | Rasgo sellado

Sealed proporciona un control exhaustivo de nuestra aplicación. La verificación exhaustiva permite verificar que todos los miembros de un rasgo sellado deben declararse en el mismo archivo que el archivo fuente. Eso significa que el compilador conoce de antemano todos los posibles miembros conocidos de un rasgo que debe incluirse. Esto nos da una ventaja para evitar errores en nuestro código. 

Sintaxis: 

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

La verificación exhaustiva se usa principalmente en la coincidencia de tipo/patrón en Scala. Digamos que tenemos un rasgo X sellado y clases que amplían el rasgo X. Al hacer coincidir los subtipos del rasgo X, debemos asegurarnos de que la inclusión de todos los subtipos conocidos sea imprescindible. El siguiente método nos daría una advertencia. Aunque obtendríamos el resultado correcto, esto podría provocar fallas inesperadas en el tiempo de ejecución de nuestra aplicación. 

Warning: match may not be exhaustive

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

La implementación correcta sería como- 

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

Echemos un vistazo al programa a continuación en el archivo guardado como language.scala : – 

Ejemplo : 

// 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
    }
}

Producción : 

scala article
java article
csharp article

• Los subtipos de un rasgo se conocen de antemano . No incluir ninguno de los subtipos de la clase C sellada en la coincidencia de patrones nos daría una advertencia. Tal advertencia le indica que existe el riesgo de que su código produzca una excepción de error de coincidencia porque no se manejan algunos patrones posibles. La advertencia apunta a una fuente potencial de fallas en tiempo de ejecución, por lo que generalmente es una ayuda bienvenida para que su programa funcione correctamente. 
   
• Los rasgos sellados solo pueden extenderse en el mismo archivo fuente que los subtipos. En el ejemplo anterior, tenemos otra clase python en otro archivo scala. Al importar los geeks de rasgos de language.scala , obtendríamos un mensaje de error como el que se muestra a continuación.

illegal inheritance from sealed trait bag

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

• La clase sellada también se usa principalmente en enumeraciones : previene la herencia ilegal y usa todo el subtipo para evitar advertencias de coincidencia exhaustivas. 
  Ejemplo :

// 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"
    }
}

Producción : 

heart
club
spade
diamond