El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este tema, aprenderemos cómo interactuar con el sistema operativo desde Haskell. Esto incluye ejecutar comandos del sistema, trabajar con procesos y manejar la entrada y salida estándar. Este conocimiento es crucial para construir aplicaciones que necesiten interactuar con el entorno del sistema operativo.

Ejecutar Comandos del Sistema

Para ejecutar comandos del sistema en Haskell, utilizamos el módulo System.Process. Este módulo proporciona funciones para ejecutar comandos y capturar su salida.

Ejemplo: Ejecutar un Comando Simple

import System.Process

main :: IO ()
main = do
    -- Ejecutar el comando 'ls' en Unix o 'dir' en Windows
    let command = "ls"  -- Cambia a "dir" si estás en Windows
    output <- readProcess command [] ""
    putStrLn output

Explicación

import System.Process: Importa el módulo necesario.
readProcess: Ejecuta un comando y captura su salida.
- Primer argumento: El comando a ejecutar.
- Segundo argumento: Lista de argumentos para el comando.
- Tercer argumento: Entrada estándar para el comando.
putStrLn output: Imprime la salida del comando.

Trabajar con Procesos

Además de ejecutar comandos simples, a veces necesitamos más control sobre los procesos, como manejar su entrada y salida estándar de manera más detallada.

Ejemplo: Ejecutar un Proceso con Control de Entrada y Salida

import System.Process
import System.IO

main :: IO ()
main = do
    -- Crear un proceso interactivo
    (Just hin, Just hout, Just herr, ph) <- createProcess (proc "ghci" [])
        { std_in = CreatePipe, std_out = CreatePipe, std_err = CreatePipe }

    -- Escribir un comando al proceso
    hPutStrLn hin ":quit"
    hFlush hin

    -- Leer la salida del proceso
    output <- hGetContents hout
    putStrLn output

    -- Esperar a que el proceso termine
    _ <- waitForProcess ph
    return ()

Explicación

createProcess: Crea un proceso con control sobre su entrada y salida.
- proc "ghci" []: Especifica el comando y sus argumentos.
- std_in = CreatePipe, std_out = CreatePipe, std_err = CreatePipe: Redirige la entrada, salida y error estándar a tuberías.
hPutStrLn hin ":quit": Escribe un comando al proceso.
hFlush hin: Asegura que el comando se envíe inmediatamente.
hGetContents hout: Lee la salida del proceso.
waitForProcess ph: Espera a que el proceso termine.

Manejo de Entrada y Salida Estándar

A veces necesitamos interactuar con la entrada y salida estándar del sistema operativo. Esto es útil para crear programas que lean de la entrada estándar y escriban a la salida estándar.

Ejemplo: Leer de la Entrada Estándar y Escribir a la Salida Estándar

main :: IO ()
main = do
    putStrLn "Escribe algo:"
    input <- getLine
    putStrLn $ "Has escrito: " ++ input

Explicación

putStrLn "Escribe algo:": Escribe un mensaje a la salida estándar.
getLine: Lee una línea de la entrada estándar.
putStrLn $ "Has escrito: " ++ input: Escribe la entrada leída a la salida estándar.

Ejercicios Prácticos

Ejercicio 1: Ejecutar un Comando del Sistema

Escribe un programa que ejecute el comando date y muestre la fecha y hora actuales.

import System.Process

main :: IO ()
main = do
    output <- readProcess "date" [] ""
    putStrLn output

Ejercicio 2: Crear un Proceso Interactivo

Escribe un programa que ejecute ghci, envíe el comando :quit y muestre la salida.

import System.Process
import System.IO

main :: IO ()
main = do
    (Just hin, Just hout, Just herr, ph) <- createProcess (proc "ghci" [])
        { std_in = CreatePipe, std_out = CreatePipe, std_err = CreatePipe }

    hPutStrLn hin ":quit"
    hFlush hin

    output <- hGetContents hout
    putStrLn output

    _ <- waitForProcess ph
    return ()

Ejercicio 3: Leer y Escribir de la Entrada y Salida Estándar

Escribe un programa que lea una línea de la entrada estándar y la escriba a la salida estándar en mayúsculas.

import Data.Char (toUpper)

main :: IO ()
main = do
    putStrLn "Escribe algo:"
    input <- getLine
    putStrLn $ map toUpper input

Conclusión

En esta sección, hemos aprendido cómo interactuar con el sistema operativo desde Haskell. Hemos cubierto cómo ejecutar comandos del sistema, trabajar con procesos y manejar la entrada y salida estándar. Estos conceptos son fundamentales para construir aplicaciones que necesiten interactuar con el entorno del sistema operativo.

En el próximo tema, exploraremos cómo manejar excepciones en Haskell, lo cual es crucial para construir aplicaciones robustas y confiables.

Interacción con el Sistema

Contenido

Ejecutar Comandos del Sistema

Ejemplo: Ejecutar un Comando Simple

Explicación

Trabajar con Procesos

Ejemplo: Ejecutar un Proceso con Control de Entrada y Salida

Explicación

Manejo de Entrada y Salida Estándar

Ejemplo: Leer de la Entrada Estándar y Escribir a la Salida Estándar

Explicación

Ejercicios Prácticos

Ejercicio 1: Ejecutar un Comando del Sistema

Ejercicio 2: Crear un Proceso Interactivo

Ejercicio 3: Leer y Escribir de la Entrada y Salida Estándar

Conclusión

Curso de Programación en Haskell

Módulo 1: Introducción a Haskell

Módulo 2: Conceptos Básicos

Módulo 3: Fundamentos de Programación Funcional

Módulo 4: Sistema de Tipos

Módulo 5: Programación Funcional Avanzada

Módulo 6: Entrada y Salida

Módulo 7: Temas Avanzados

Módulo 8: Haskell Práctico