No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Scala básico

Curso de Scala básico

Carlos Daniel Sanchez

Carlos Daniel Sanchez

Tipos genéricos

20/36
Recursos

¿Qué es un tipo genérico?

Los tipos genéricos representan un concepto muy poderoso en programación que actúa como un comodín de datos. En esencia, un tipo genérico es un tipo de dato que se adapta según nuestras necesidades, sin requerir una definición específica en cada ocasión. Esto simplifica el código enormemente, ya que permite crear funciones o estructuras de datos sin especificar el tipo de dato exacto con el que están trabajando. Sin embargo, es crucial usarlos con cautela para evitar generar código difícil de comprender. En tiempo de compilación, el compilador convierte estos datos genéricos en tipos específicos según su uso.

¿Cuál es la diferencia entre tipos genéricos y específicos?

A la hora de programar, podemos toparnos con lenguajes que no soportan tipos genéricos, lo cual significa que cada función debe ser definida para tipos específicos de datos. Esto puede convertirse en una tarea repetitiva y tediosa. Los tipos genéricos, por otra parte, ahorran tiempo y esfuerzo al permitir que una sola función maneje múltiples tipos de datos. Sin embargo, su abuso puede complicar la lectura y mantenimiento del código, así que un equilibrio es vital.

¿Cómo se definen los tipos genéricos en Scala?

Scala, a diferencia de otros lenguajes, brinda flexibilidad para definir tipos genéricos tanto en traits como en clases. Veamos cómo hacerlo con un par de ejemplos.

Definición de una función con un tipo de dato genérico

Para definir una función con un tipo de dato genérico en Scala, seguimos estos pasos:

def f[A](x: A): String = s"El valor es $x"

Aquí, A es el tipo genérico, y usamos corchetes para indicarle al compilador que A es un tipo genérico. El compilador infiere el tipo específico durante la compilación. Por ejemplo:

  • Si invocamos f(23), A será un Int.
  • Si invocamos f(true), A será un Boolean.

Definición en un trait

La definición de tipos genéricos en un trait es similar:

trait Ejemplo[A, B] {
  def g(x: A, funcion: A => B): B = funcion(x)
}

Aquí, g es una función que toma un valor x de tipo A, una función que convierte A a B, y retorna un B. Para usar el trait, necesitamos definir un objeto:

object EjemploUso extends Ejemplo[Int, String] {
  def main(args: Array[String]): Unit = {
    // Utilizamos la función f definida anteriormente
    println(g(3, f))
  }
}

Este object define que el tipo A es un Int y el tipo B es un String. Así, en tiempo de ejecución, al llamar EjemploUso.g(3, f), pasamos la función f y un entero 3.

Les invito a experimentar con estos tipos genéricos en Scala para entender mejor su potencial y limitaciones. En futuros temas de programación funcional, estos conceptos serán aún más importantes cuando nos adentremos en tipos de datos algebraicos. ¡No se desanimen, sigan explorando y expandiendo su conocimiento en programación!

Aportes 5

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

con corchetes se puede especificar que es tipo genericos, [A]

Los trais no pueden existir por mismo, tenemos que crear un objeto para poderlo usar, ejemplo: object ejemplo entends ejemplo

El tipo Genérico podría ser un simil al Any de TypeScript?

Tipos genéricos

¿Qué son?

Un tipo genérico se comporta como un comodín. Nos permite tener certeza sobre un tipo sin saber cuán es aun.

Específico vs. Genérico

En lenguajes sin fuertes fundamentos de programación genérica, como Go, se usa un estilo donde hay que ser específicos con los tipos. Lenguajes como Scala, se da una flexibilidad mayor, con todo lo bueno y malo que esto trae

En tiempo de compilación

Los tipos genéricos son especializados al momento de compilar. Es decir, que si una combinación no tiene sentido, el programa no compilará.

¿Dónde puede aplicarse?

Scala es muy flexible de en dónde se puede definir un tipo genérico. Puede definirse a nivel de función, de clase, o de trait.

def f[A](x: A): String = s"$x"
//f: [A](x: A)String

f(23)
//res: String = 23

f(true)
//res: String = true

trait ejemplo[A,B] {
	def g(x: A, f: A => B): B = f(x)
}
//defined trait ejemplo

object ejemplo extends ejemplo[Int, String]

ejemplo.g(3, f)
//res: String = 3


def f[A](x: A): String = s"$x"
 #:::::::::::::::::::::::::

trait ejemplo[A,B]{
def g(x: A, f: A=> B): B = f(x)
}

object ejemplo extends ejemplo[Int, String]

ejemplo.g

ejemplo.g(3, f)