con corchetes se puede especificar que es tipo genericos, [A]
Introducción a Scala y configuración del entorno de desarrollo
Introducción al curso y presentación de los objetivos
Scala en la historia
Instalando JVM, SBT y editores
Instalación de las herramientas
¡Hola, Mundo!
Fundamentos de Programación Funcional
Tipos de datos básicos
Inmutabilidad
Expresiones
Funciones
Colecciones: Secuencias, Conjuntos y Mapas
Tuplas y Objetos
La función de copy y el concepto de Lences
Conceptos básicos de Programación Funcional
Pattern Matching
Tail recursion
Agregación
Fundamentos teoricos
Funciones totales y parciales
Razonamiento inductivo
Razonamiento con tipos
Traits
Tipos genéricos
Tipos de datos algebraicos
Evaluación peresoza (Lazy)
Disyunciones: Option
Disyunciones: Either, try
Proyecto de Backend
Introducción e iniciación del proyecto
Modelo por Actores
Modelo de datos
Configuración de Slick
Controladores: Cómo obtener información de la base de datos
Controladores: Crear, actualizar y eliminar información de la base de datos
Computación paralela, asíncrona y concurrente
Serialización
Validación
Manejo de errores en el proyecto
Exportación del proyecto
Conclusiones
Clase final
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
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.
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.
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.
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:
f(23)
, A
será un Int
.f(true)
, A
será un Boolean
.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
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?
Un tipo genérico se comporta como un comodín. Nos permite tener certeza sobre un tipo sin saber cuán es aun.
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
Los tipos genéricos son especializados al momento de compilar. Es decir, que si una combinación no tiene sentido, el programa no compilará.
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)
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?