Escala | variaciones

La varianza es la interconexión de las relaciones de subtipificación que son de tipos complicados o de sus tipos constituyentes. La varianza explica la correlación de herencia de los tipos que tienen parámetros o argumentos dentro de ellos. Estos tipos pertenecen a las clases genéricas , que toman un tipo como un parámetro. En presencia de Varianza se pueden crear relaciones entre tipos complicados y en su ausencia no podremos reiterar la clase de abstracción. Las Varianzas de Scala son de tres tipos, las cuales son las siguientes:

1. covariante
2. contravariante
3. Invariante

Algunos puntos importantes:

• En la colección de Scala, los tipos se pueden construir de forma más segura a través de Variances.
• Las variaciones pueden proporcionarnos algunos avances extra ajustables.
• También ayuda en el desarrollo de aplicaciones auténticas.
• Las variaciones se pueden aplicar en cualquier tipo de Scala como Lista, Conjuntos, etc.

Analicemos cada tipo en detalle.

• Covariante: si una clase genérica tiene un parámetro de tipo T, entonces su notación Covariante será [+T]. Supongamos que tenemos dos tipos de listas de Scala, es decir, S y T. Donde S es un subtipo de T, entonces puede decir que List[S] es también el subtipo de List[T]. Si dos tipos están relacionados de esta manera, caen bajo el tipo Covariante. List[T] se puede llamar como Generic .
  Sintaxis:

  List[+T]

  Aquí, T es el parámetro de tipo y + es el símbolo de Covarianza.
  Ejemplo:

  // Scala program of covariant // type    // Creating an abstract class // for Student abstract class Student {     def name: String }    // Creating a sub-class Girls // of Student case class Girls(name: String) extends Student    // Creating a sub-class Boys // of Student case class Boys(name: String) extends Student    // Creating an Object Covariance // that inherits main method of // App object Covariance extends App {     // Creating a method     def Studentnames(students: List[Student]): Unit =     {         students.foreach { student =>                // Displays students name         println(student.name)     }     }        // Assigning names      val boys: List[Boys] = List(Boys("Kanchan"), Boys("Rahul"))     val girls: List[Girls] = List(Girls("Nidhi"), Girls("Geeta"))        // Accessing list of boys     Studentnames(boys)        // Accessing list of girls     Studentnames(girls) }

  Producción:

  Kanchan
  Rahul
  Nidhi
  Geeta
  

  Aquí, la Lista de niños y niñas pertenece a la Lista de estudiantes ya que son su subtipo y, por lo tanto, aquí se muestran los nombres de todos los estudiantes cuando se llama al Estudiante de tipo Super.
  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 los objetos en programas viables.

 

• Contravariante: Si una clase genérica tiene un parámetro de tipo T, entonces su notación Contravariante será [-T]. Supongamos que tenemos dos tipos de listas de Scala, es decir, S y T. Donde S es un subtipo de T, pero List[T] es el subtipo de List[S]. Si dos tipos están relacionados de esta manera, caen dentro del tipo Contravariante. Es lo contrario de covariante.
  Sintaxis:

  List[-T]

  Aquí, T es el parámetro de tipo y – es el símbolo de Contravarianza.
  Ejemplo:

  // Scala program of Variance of // Contravariant type    // abstract class with a contravariant  // type parameter abstract class Show[-T]  {        // Method for printing     // type T     def print(value: T): Unit }    // A class structure abstract class Vehicle {     def name: String }    // Creating sub-class of Vehicle case class Car(name: String) extends Vehicle    // Creating sub-class of class // Show class VehicleShow extends Show[Vehicle]  {     def print(vehicle: Vehicle): Unit =        // Displays name of the vehicle     println("The name of the vehicle is: " + vehicle.name) }    // Creating sub-class of class // Show class CarShow extends Show[Car]  {     def print(car: Car): Unit =        // Displays name of the car     println("The name of the car is: " + car.name) }    // Inheriting main method of  // the trait App object Contravariance extends App  {        // Assigning value to the name      val newCar: Car = Car("Scorpio")        // Defining a method that     // prints the name     def printnewCar(show: Show[Car]): Unit =      {         show.print(newCar)     }        // Creating objects     val showcar: Show[Car] = new CarShow     val showvehicle: Show[Vehicle] = new VehicleShow        // Accessing name     printnewCar(showcar)     printnewCar(showvehicle) }

  Producción:

  The name of the car is: Scorpio
  The name of the vehicle is: Scorpio
  

  Es contravariante, por lo que podemos sustituir Show[Vehicle] por Show[Car] y es por eso que tanto el vehículo como el automóvil devuelven el mismo nombre.

• Invariante: en Scala, los tipos genéricos son invariantes por defecto. Supongamos que tenemos dos tipos de Lista de Scala, es decir, S y T. Donde S es un subtipo de T pero Lista [T] y Lista [S] no están relacionadas en absoluto, entonces caen bajo el tipo invariable.
  Sintaxis:

  List[T]

  Aquí, no usamos ningún símbolo para la relación invariante.
  Nota: Las clases como Array[T], ListBuffer[T], ArrayBuffer[T], etc. son mutables, por lo que tienen un parámetro de tipo invariable, si usamos parámetros de tipo invariable en la relación de herencia o subtipo, obtendremos una compilación error.