La coincidencia de patrones es una característica poderosa y fundamental en Haskell que permite descomponer datos y ejecutar código basado en la estructura de los datos. Es una herramienta esencial para trabajar con tipos de datos algebraicos, listas, tuplas y más.

Conceptos Clave

  1. Patrones: Son formas de especificar la estructura de los datos que queremos descomponer.
  2. Coincidencia de Patrones en Funciones: Permite definir funciones de manera más clara y concisa.
  3. Patrones en Listas y Tuplas: Facilita la manipulación de estructuras de datos comunes.
  4. Patrones en Tipos de Datos Algebraicos: Es crucial para trabajar con tipos de datos definidos por el usuario.

Coincidencia de Patrones en Funciones

La coincidencia de patrones se utiliza comúnmente en la definición de funciones. Aquí hay un ejemplo simple:

-- Definición de una función que suma dos números
sumar :: Int -> Int -> Int
sumar 0 y = y
sumar x y = x + y

Explicación

  • sumar 0 y = y: Este patrón coincide cuando el primer argumento es 0. En este caso, la función simplemente devuelve el segundo argumento.
  • sumar x y = x + y: Este patrón coincide con cualquier otro par de enteros, sumándolos.

Patrones en Listas

La coincidencia de patrones es especialmente útil para trabajar con listas. Aquí hay un ejemplo:

-- Definición de una función que calcula la longitud de una lista
longitud :: [a] -> Int
longitud [] = 0
longitud (_:xs) = 1 + longitud xs

Explicación

  • longitud [] = 0: Este patrón coincide con una lista vacía y devuelve 0.
  • longitud (_:xs) = 1 + longitud xs: Este patrón coincide con una lista no vacía. _ ignora el primer elemento, y xs es el resto de la lista. La función devuelve 1 más la longitud del resto de la lista.

Patrones en Tuplas

Las tuplas también pueden ser descompuestas usando patrones:

-- Definición de una función que suma los elementos de una tupla
sumarTupla :: (Int, Int) -> Int
sumarTupla (x, y) = x + y

Explicación

  • sumarTupla (x, y) = x + y: Este patrón coincide con una tupla de dos enteros y suma sus elementos.

Patrones en Tipos de Datos Algebraicos

La coincidencia de patrones es crucial para trabajar con tipos de datos definidos por el usuario. Aquí hay un ejemplo con un tipo de datos algebraico:

-- Definición de un tipo de datos algebraico para una lista de enteros
data ListaEnteros = Vacia | Cons Int ListaEnteros

-- Definición de una función que calcula la longitud de una ListaEnteros
longitudListaEnteros :: ListaEnteros -> Int
longitudListaEnteros Vacia = 0
longitudListaEnteros (Cons _ xs) = 1 + longitudListaEnteros xs

Explicación

  • longitudListaEnteros Vacia = 0: Este patrón coincide con una lista vacía y devuelve 0.
  • longitudListaEnteros (Cons _ xs) = 1 + longitudListaEnteros xs: Este patrón coincide con una lista no vacía. Cons _ xs descompone la lista en su primer elemento (ignorado con _) y el resto de la lista (xs).

Ejercicios Prácticos

Ejercicio 1: Coincidencia de Patrones en Listas

Define una función primerElemento que devuelve el primer elemento de una lista. Si la lista está vacía, debe devolver Nothing.

primerElemento :: [a] -> Maybe a
primerElemento [] = Nothing
primerElemento (x:_) = Just x

Ejercicio 2: Coincidencia de Patrones en Tuplas

Define una función swap que intercambia los elementos de una tupla de dos elementos.

swap :: (a, b) -> (b, a)
swap (x, y) = (y, x)

Ejercicio 3: Coincidencia de Patrones en Tipos de Datos Algebraicos

Define un tipo de datos algebraico Arbol para representar un árbol binario y una función altura que calcula la altura del árbol.

data Arbol = Hoja | Nodo Int Arbol Arbol

altura :: Arbol -> Int
altura Hoja = 0
altura (Nodo _ izq der) = 1 + max (altura izq) (altura der)

Soluciones

Solución al Ejercicio 1

primerElemento :: [a] -> Maybe a
primerElemento [] = Nothing
primerElemento (x:_) = Just x

Solución al Ejercicio 2

swap :: (a, b) -> (b, a)
swap (x, y) = (y, x)

Solución al Ejercicio 3

data Arbol = Hoja | Nodo Int Arbol Arbol

altura :: Arbol -> Int
altura Hoja = 0
altura (Nodo _ izq der) = 1 + max (altura izq) (altura der)

Conclusión

La coincidencia de patrones es una herramienta poderosa en Haskell que permite descomponer y manipular datos de manera clara y concisa. Es fundamental para trabajar con listas, tuplas y tipos de datos algebraicos. Practicar con estos conceptos te ayudará a escribir código más limpio y eficiente en Haskell. En el próximo tema, exploraremos las guardas, que permiten añadir condiciones adicionales a los patrones.

© Copyright 2024. Todos los derechos reservados