Escala | Límite inferior

Type Bound básicamente es un tipo de restricción en el parámetro o la variable. Mediante el uso de estos límites de tipo podemos establecer límites para las variables. Estos límites ayudan a poner nuestro código en ejemplos del mundo real. Necesitamos imponer ciertas limitaciones y límites a cada factor en la vida real, eso es lo que hacen los límites de Tipo en Scala.

Hay principalmente 2 tipos de límites de tipo:

Estaremos más preocupados por los Límites Inferiores en esta sección. Los límites inferiores de tipo se utilizan para declarar un supertipo de otro tipo. Un límite inferior se denota por >: . Cualquier declaración de límite inferior se puede escribir como ‘[T>:S]’ . Aquí T es un parámetro de tipo y S es un tipo. La declaración de límite inferior anterior significa que el parámetro de tipo T debe ser el mismo que S o un supertipo de S.

Entendamos sobre el supertipo, supongamos que escribimos S>: T, entonces esta declaración de límite inferior siempre tiene T igual a S o menor que S, lo que significa que T está vinculado en este caso. Entonces podemos decir que T es un supertipo de S.

Sintaxis:

[T >: Demo[T]]

En el caso anterior, hemos definido un límite inferior desde el parámetro de tipo T hasta el tipo Demo. Y T debe ser un Demo o un supertipo de tipo Demo.

Tomemos otro ejemplo
si declaro todas las clases en cierto formato como se muestra a continuación:

trait Food
class eatables extends Food
class drinks extends Food
class fruits extends eatables
class vegetables extends eatables
class cold_drinks extends drinks
class hot_drinks extends drinks

class position[A](val place:A) 

Ahora todas las clases, así como las subclases, se han declarado utilizando las declaraciones anteriores. Entonces, si consideramos la declaración position[A], aquí position es genérica y A es del tipo abstracto. Esto se puede simplificar aún más, la posición [A] indica que el valor requerido para pasar a lugar debe ser del tipo A. Lo que significa que si doy una posición de comando [frutas], se creará con una instancia de Frutas. Así que para comprobar esto vamos a ver un ejemplo:

new position[fruits](new fruits)
new position[fruits](new drinks)
new position[eatables](new vegetables)

En el ejemplo dado anteriormente, notaremos que la primera declaración se compilará, pero la segunda declaración mostrará errores porque las frutas y las bebidas no son del mismo tipo. Por otro lado, se compilará la tercera declaración porque el vegetal es un subtipo de comestibles. Ahora usando algunos comandos de límite inferior en las declaraciones anteriores:

class position[A >: fruits](val place=A)

Con esta declaración podemos decir que podemos posicionar cualquier supertipo de frutas, lo que significa comestibles y Alimentos. Entonces, con esto definitivamente podemos ver que los límites inferiores de Scala pueden ser muy útiles y adoptivos si se usa alguna lógica para cualquier ejemplo del mundo real. Por lo tanto, podemos agregar todas las limitaciones y restricciones de la vida real sobre nuestras variables que estamos usando en el lenguaje de codificación.

Ejemplo:

// Scala Program To Demonstrate Scala Lower Bound
class GeeksforGeeks
class Author extends GeeksforGeeks
class Geeks extends GeeksforGeeks
  
class ComputerSciencePortal
{
    // Declaration of Lower bound
    def display [T >: Geeks](d : T)
    {
        println(d)
    }
}
  
// Object created
object ScalaUpperBounds
{
    // Driver code
    def main(args: Array[String])
    {
  
        val geeksforgeeks = new GeeksforGeeks
        val author = new Author
        val geeks = new Geeks
  
        val computerscienceportal = new ComputerSciencePortal
  
        computerscienceportal.display(geeksforgeeks)
        computerscienceportal.display(geeks)
        computerscienceportal.display(author)
    }
}

GeeksforGeeks@506e1b77
Geeks@4fca772d
Author@9807454

Aquí, el límite inferior se define en la clase ComputerSciencePortal, y GeeksforGeeks es la clase Super de Author. se acepta en cota inferior.

// Scala Program To Demonstrate Scala Lower Bound
class Principal
class Teacher extends Principal
class Student extends Teacher
  
class School
{
    // Declaration of lower bound
    def display [T >: Teacher](t: T)
    {
        println(t)
    }
}
  
// Object created
object ScalaUpperBounds
{
    // Driver code
    def main(args: Array[String])
    {
        // Defined new variable
        val principal = new Principal
        val teacher = new Teacher
        val student = new Student
  
        val school = new School
          
        school.display(principal)
        school.display(teacher)
        school.display(student)
}
}

Principal@506e1b77
Teacher@4fca772d
Student@9807454

Aquí, hemos definido el límite inferior en Class School, es decir, [T >: Teacher], lo que implica que el método de visualización acepta el objeto de la clase Principal o una subclase de este (es decir, Teacher) o una subclase de la clase Teacher (es decir, Student), lo que significa que la superclase de El maestro será aceptado.