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

Funtores Aplicativos

Siguiente ►
►

Introducción

En Haskell, los funtores aplicativos (o simplemente aplicativos) son una abstracción que permite aplicar funciones contenidas en contextos (como Maybe, List, etc.) a valores también contenidos en contextos. Los aplicativos son más poderosos que los funtores, pero menos que las mónadas. Este módulo te enseñará cómo funcionan los aplicativos y cómo puedes utilizarlos en tus programas Haskell.

Conceptos Clave

  1. Funtor Aplicativo: Una estructura que permite aplicar funciones dentro de un contexto.
  2. Clase de Tipo Applicative: Define las operaciones necesarias para trabajar con funtores aplicativos.
  3. Operadores pure y <*>: Los operadores fundamentales para trabajar con aplicativos.

Clase de Tipo Applicative

La clase de tipo Applicative se define en el módulo Control.Applicative y es una extensión de la clase Functor. Aquí está la definición simplificada:

class Functor f => Applicative f where
    pure  :: a -> f a
    (<*>) :: f (a -> b) -> f a -> f b
  • pure: Toma un valor y lo coloca en un contexto.
  • <*>: Toma una función en un contexto y un valor en un contexto, y aplica la función al valor.

Ejemplos Prácticos

Ejemplo 1: Maybe como Aplicativo

El tipo Maybe es un ejemplo común de un funtor aplicativo. Aquí hay un ejemplo de cómo usar pure y <*> con Maybe:

import Control.Applicative

-- Usando `pure` para colocar un valor en un contexto `Maybe`
example1 :: Maybe Int
example1 = pure 5
-- Resultado: Just 5

-- Usando `<*>` para aplicar una función en un contexto `Maybe`
example2 :: Maybe Int
example2 = Just (+3) <*> Just 5
-- Resultado: Just 8

-- Usando `<*>` con un `Nothing`
example3 :: Maybe Int
example3 = Just (+3) <*> Nothing
-- Resultado: Nothing

Ejemplo 2: Listas como Aplicativos

Las listas también son funtores aplicativos. Aquí hay un ejemplo:

-- Usando `pure` con listas
example4 :: [Int]
example4 = pure 5
-- Resultado: [5]

-- Usando `<*>` con listas
example5 :: [Int]
example5 = [(+1), (*2)] <*> [1, 2, 3]
-- Resultado: [2,3,4,2,4,6]

Ejemplo 3: Aplicativos en Expresiones

Los aplicativos son útiles para trabajar con múltiples contextos. Aquí hay un ejemplo más complejo:

-- Usando `pure` y `<*>` en una expresión
example6 :: Maybe Int
example6 = pure (+) <*> Just 3 <*> Just 5
-- Resultado: Just 8

-- Usando `pure` y `<*>` con listas
example7 :: [Int]
example7 = pure (+) <*> [1, 2] <*> [3, 4]
-- Resultado: [4,5,5,6]

Ejercicios Prácticos

Ejercicio 1: Aplicar Funciones en Contextos Maybe

Dado el siguiente código, completa las expresiones para que el resultado sea Just 10:

import Control.Applicative

-- Completa las expresiones
exercise1 :: Maybe Int
exercise1 = pure (*) <*> Just 2 <*> Just 5

Ejercicio 2: Aplicar Funciones en Listas

Dado el siguiente código, completa las expresiones para que el resultado sea [4, 5, 6, 5, 6, 7]:

-- Completa las expresiones
exercise2 :: [Int]
exercise2 = pure (+) <*> [1, 2] <*> [3, 4]

Soluciones

Solución al Ejercicio 1

import Control.Applicative

exercise1 :: Maybe Int
exercise1 = pure (*) <*> Just 2 <*> Just 5
-- Resultado: Just 10

Solución al Ejercicio 2

exercise2 :: [Int]
exercise2 = pure (+) <*> [1, 2] <*> [3, 4]
-- Resultado: [4, 5, 6, 5, 6, 7]

Conclusión

En este módulo, hemos aprendido sobre los funtores aplicativos y cómo utilizarlos en Haskell. Hemos visto cómo la clase de tipo Applicative extiende Functor y proporciona las operaciones pure y <*> para trabajar con funciones y valores en contextos. Los ejemplos y ejercicios prácticos te ayudarán a consolidar estos conceptos y aplicarlos en tus propios programas.

En el próximo módulo, exploraremos los transformadores de mónadas, una herramienta poderosa para trabajar con múltiples contextos anidados.

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