Scala – Covarianza

La varianza es la interconexión de las relaciones de subtipificación que son de tipos complicados o de sus tipos constituyentes. Scala proporciona tres tipos de varianza:

• covariante
• contravariante
• Invariante

La covarianza establece que si hay dos tipos parametrizados tales que S es un subtipo de T, entonces List[S] es un subtipo de List[T]. Esta es una relación de herencia. Entonces, esto define básicamente la relación de si podemos reemplazar un tipo por su tipo base. Simplemente poniéndolo en palabras, si tomamos un ejemplo donde Car es un subtipo de Vehicle, entonces List[Car] es un subtipo de List[Vehicle]. Por lo tanto, podemos reemplazar List[Car] por List[Vehicle]. Cuando declaramos que un tipo es covariante, su uso seguro en varias posiciones se vuelve limitado. En el caso de tipos inmutables, la covarianza se usa ampliamente.
Sintaxis:

List[+T]

Aquí, T es un parámetro de tipo y el símbolo «+» representa la covarianza de Scala.

Discutamos este concepto con la ayuda de ejemplos:
Ejemplo 1:

// Scala program to illustrate the concept of covariance
  
// Creating an abstract class 
// for Flower 
abstract class Flower 
{
    def name: String
}
  
// Creating a sub-class Lily 
// of Flower 
case class Lily(name: String) extends Flower
  
// Creating a sub-class Carnation
// of Flower 
case class Carnation(name: String) extends Flower 
object Covariance extends App
{
      
    // Creating a method
    def FlowerNames(flowers: List[Flower]): Unit =
    {   
        flowers.foreach 
        {
            flower => println(flower.name)
        }
    }
      
    // Assigning names
    val lily: List[Lily] = List(Lily("White Lily"), 
                                Lily("Jersey Lily"))
    val carnations: List[Carnation] = List(Carnation("White carnations"),
                                           Carnation("Pink carnations"))
  
    // Print: names of lily 
    FlowerNames(lily)
  
    // Print: names of carnation 
    FlowerNames(carnations)
}

Producción:

White Lily
Jersey Lily
White carnations
Pink carnations

Explicación: En el ejemplo anterior, Lily y Carnation son subtipos de Flower. Entonces, es evidente que una Lista[Lirio] es una Lista[Flor] y una Lista[Clave] es también una Lista[Flor], y podemos sustituir cualquiera de ellas por una Lista[Flor]. En la última parte del código, hay un método FlowerNames que imprime nombres de flores y el argumento aceptable es una lista de flores. Si las dos listas son covariantes, solo entonces se compilarán las llamadas al método y se imprimirán los nombres de las flores, respectivamente. Entonces, como Lily y Carnation son un subtipo de Flowers y las dos últimas líneas se ejecutarán debido a la covarianza.
Nota:

• La clase abstracta se utiliza aquí para aplicar la covarianza, ya que tiene List[+T] donde el parámetro de tipo T es covariante.
• Aquí se utiliza una aplicación de características para convertir rápidamente objetos en programas viables.

Ejemplo 2:

// Scala program to illustrate the concept of covariance
  
// Creating an abstract class 
// for Animal
abstract class Animal 
{
    def name: String
}
  
// Creating a sub-class Mammal
// of Animal 
case class Mammal(name: String) extends Animal
  
// Creating a sub-class Reptile
// of Animal 
case class Reptile(name: String) extends Animal 
  
object CovarianceExample extends App
{
      
    // Creating a method
    def SpecieNames(animals: List[Animal]): Unit =
    {   
        animals.foreach 
        { 
            animal =>println(animal.name)
        }
    }
      
    // Assigning names
    val mammals: List[Mammal] = List(Mammal("Zebra"), 
                                     Mammal("Horse"))
    val reptiles: List[Reptile] = List(Reptile("Snake"), 
                                       Reptile("Lizard"))
  
    // Print: names of mammals
    SpecieNames(mammals)
  
    // Print : names of reptiles
    SpecieNames(reptiles)
}

Producción:

Zebra
Horse
Snake
Lizard