En Elm, al igual que en muchos lenguajes funcionales, los tipos genéricos permiten escribir funciones y estructuras de datos que funcionan con diferentes tipos sin necesidad de duplicar código.
Un tipo genérico se indica con letras minúsculas como a, b, c, etc.
Veamos un ejemplo simple:
identity : a -> a
identity x =
x
Aquí, la función identity recibe un valor de cualquier tipo a y lo devuelve.
- Si le paso un Int, devuelve un Int.
- Si le paso un String, devuelve un String.
identity 42
-- Resultado: 42
identity "hola"
-- Resultado: "hola"
Las listas en Elm también son genéricas.
Su tipo es List a, donde a puede ser cualquier tipo.
longitud : List a -> Int
longitud lista =
List.length lista
longitud puede recibir:
longitud [1, 2, 3] -- funciona con List Int
longitud ["a", "b", "c"] -- funciona con List String
En ambos casos la función devuelve la cantidad de elementos, sin importar de qué tipo sean.
Las tuplas también soportan tipos genéricos:
swap : (a, b) -> (b, a)
swap (x, y) =
(y, x)
Ejemplo de uso:
swap (1, "uno")
-- Resultado: ("uno", 1)
swap (True, 3.14)
-- Resultado: (3.14, True)
Podemos crear estructuras más complejas con varios genéricos:
maybeFirst : List a -> Maybe a
maybeFirst lista =
case lista of
[] ->
Nothing
x :: _ ->
Just x
- Si la lista está vacía, devuelve Nothing.
- Si tiene elementos, devuelve Just el primero.
Funciona con cualquier tipo de lista:
maybeFirst [1, 2, 3] -- Just 1
maybeFirst ["a", "b"] -- Just "a"
maybeFirst [] -- Nothing
Los tipos genéricos se escriben con letras minúsculas (a, b, c).
- Permiten que funciones y estructuras trabajen con cualquier tipo.
- Están presentes en funciones (identity), listas (List a), tuplas ((a, b)), y en tipos como Maybe a.
- Nos ayudan a escribir código más reutilizable y flexible.
