El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Manejo de Excepciones

Siguiente ►
►

En Haskell, el manejo de excepciones es un aspecto crucial para escribir programas robustos y confiables. A diferencia de muchos lenguajes imperativos, Haskell maneja las excepciones de una manera que se integra con su naturaleza funcional. En este tema, aprenderemos cómo capturar y manejar excepciones en Haskell.

Conceptos Clave

  1. Excepciones en Haskell: Haskell proporciona un sistema de excepciones que permite a los programas manejar errores de manera controlada.
  2. Módulo Control.Exception: Este módulo contiene las funciones y tipos necesarios para trabajar con excepciones.
  3. Tipos de Excepciones: Haskell distingue entre excepciones síncronas (errores de programación) y asíncronas (interrupciones externas).

Módulo Control.Exception

El módulo Control.Exception es la base para el manejo de excepciones en Haskell. Aquí están algunas de las funciones y tipos más importantes:

  • catch: Captura una excepción y permite manejarla.
  • try: Similar a catch, pero devuelve un Either en lugar de lanzar una excepción.
  • throwIO: Lanza una excepción en el contexto de IO.
  • SomeException: Tipo de datos que puede representar cualquier excepción.

Ejemplo Básico de catch

import Control.Exception

main :: IO ()
main = do
    result <- try (readFile "nonexistent.txt") :: IO (Either IOException String)
    case result of
        Left ex  -> putStrLn $ "Caught exception: " ++ show ex
        Right content -> putStrLn content

En este ejemplo, intentamos leer un archivo que no existe. La función try captura la excepción y devuelve un Either que puede ser manejado de manera segura.

Ejemplo de throwIO

import Control.Exception

main :: IO ()
main = do
    throwIO (userError "This is a user error")
    putStrLn "This will not be printed"

En este ejemplo, lanzamos una excepción usando throwIO. La línea siguiente no se ejecutará debido a la excepción.

Tipos de Excepciones

Haskell tiene varios tipos de excepciones, pero las más comunes son:

  • IOException: Errores relacionados con la entrada/salida.
  • ArithException: Errores aritméticos como división por cero.
  • AsyncException: Excepciones asíncronas como interrupciones de usuario.

Manejo de Excepciones Específicas

Podemos capturar excepciones específicas utilizando patrones de coincidencia:

import Control.Exception

main :: IO ()
main = do
    result <- try (evaluate (5 `div` 0)) :: IO (Either ArithException Int)
    case result of
        Left ex  -> putStrLn $ "Caught arithmetic exception: " ++ show ex
        Right val -> putStrLn $ "Result: " ++ show val

En este ejemplo, capturamos una excepción aritmética específica (división por cero).

Ejercicios Prácticos

Ejercicio 1: Captura de Excepciones de IO

Escribe un programa que intente leer un archivo y capture cualquier excepción de IO, imprimiendo un mensaje de error adecuado.

import Control.Exception
import System.IO

main :: IO ()
main = do
    putStrLn "Enter the filename:"
    filename <- getLine
    result <- try (readFile filename) :: IO (Either IOException String)
    case result of
        Left ex  -> putStrLn $ "Error reading file: " ++ show ex
        Right content -> putStrLn content

Ejercicio 2: Manejo de Excepciones Aritméticas

Escribe un programa que realice una operación aritmética y capture cualquier excepción aritmética, imprimiendo un mensaje de error adecuado.

import Control.Exception

main :: IO ()
main = do
    putStrLn "Enter two numbers to divide:"
    num1 <- readLn
    num2 <- readLn
    result <- try (evaluate (num1 `div` num2)) :: IO (Either ArithException Int)
    case result of
        Left ex  -> putStrLn $ "Arithmetic error: " ++ show ex
        Right val -> putStrLn $ "Result: " ++ show val

Resumen

En esta sección, hemos aprendido cómo manejar excepciones en Haskell utilizando el módulo Control.Exception. Hemos visto cómo capturar excepciones específicas y cómo lanzar nuestras propias excepciones. Estos conceptos son fundamentales para escribir programas Haskell robustos y confiables.

En el siguiente módulo, exploraremos temas avanzados como la concurrencia y el paralelismo, que nos permitirán escribir programas más eficientes y escalables.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados