-- Función simple con signatura de tipo
cuadrado :: Int -> Int
cuadrado x = x * x

-- Función con múltiples parámetros
suma :: Int -> Int -> Int
suma x y = x + y

-- Función de orden superior
aplicarDosVeces :: (a -> a) -> a -> a
aplicarDosVeces f x = f (f x)

-- Composición de funciones
(.) :: (b -> c) -> (a -> b) -> a -> c
resultado = (cuadrado . suma 3) 5  -- (5 + 3)²

-- Tipo suma (union type)
data Color = Rojo | Verde | Azul | RGB Int Int Int
  deriving (Show, Eq)

-- Tipo producto con parámetros
data Persona = Persona
  { nombre :: String
  , edad :: Int
  , email :: String
  } deriving (Show, Eq)

-- Tipo recursivo
data Lista a = Vacia | Cons a (Lista a)
  deriving (Show, Eq)

-- Tipo paramétrico (Maybe es el equivalente a Optional/Nullable)
data Maybe a = Nothing | Just a

-- Pattern matching exhaustivo
factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)

-- Con guardas (guards)
clasificarEdad :: Int -> String
clasificarEdad edad
  | edad < 13    = "Niño"
  | edad < 20    = "Adolescente"
  | edad < 60    = "Adulto"
  | otherwise    = "Adulto mayor"

-- Pattern matching con tipos algebraicos
procesarColor :: Color -> String
procesarColor Rojo = "Color primario: rojo"
procesarColor Verde = "Color primario: verde"
procesarColor Azul = "Color primario: azul"
procesarColor (RGB r g b) = "RGB(" ++ show r ++ "," ++ show g ++ "," ++ show b ++ ")"

-- Listas y rangos
numeros = [1, 2, 3, 4, 5]
infinitos = [1..]
pares = [2, 4..20]

-- List comprehensions
cuadrados = [x^2 | x <- [1..10]]
filtrados = [x | x <- [1..20], even x, x > 10]
combinaciones = [(x, y) | x <- [1..3], y <- ['a'..'c']]

-- Funciones de orden superior
duplicados = map (*2) [1..5]              -- [2,4,6,8,10]
filtrados' = filter even [1..10]          -- [2,4,6,8,10]
suma = foldl (+) 0 [1..10]                -- 55
producto = foldr (*) 1 [1..5]             -- 120

-- Operadores de lista
cabeza = head [1,2,3]                     -- 1
cola = tail [1,2,3]                       -- [2,3]
concatenacion = [1,2] ++ [3,4]            -- [1,2,3,4]
elemento = 3 `elem` [1,2,3,4]             -- True

-- Maybe para manejar valores nulos
dividir :: Float -> Float -> Maybe Float
dividir _ 0 = Nothing
dividir x y = Just (x / y)

-- IO para efectos de entrada/salida
main :: IO ()
main = do
  putStrLn "¿Cómo te llamas?"
  nombre <- getLine
  putStrLn ("Hola, " ++ nombre ++ "!")

-- Either para manejo de errores
data Error = DivisionPorCero | NumeroNegativo

calcularRaiz :: Float -> Either Error Float
calcularRaiz x
  | x < 0     = Left NumeroNegativo
  | otherwise = Right (sqrt x)

-- Solo se evalúa cuando se necesita
infinitos = [1..]
primerosCinco = take 5 infinitos  -- [1,2,3,4,5]

-- Permite estructuras de datos infinitas
fibonacci = 0 : 1 : zipWith (+) fibonacci (tail fibonacci)

-- Las estructuras de datos son inmutables por defecto
lista1 = [1, 2, 3]
lista2 = 0 : lista1  -- [0, 1, 2, 3] (lista1 no cambia)

-- Modificaciones crean nuevas estructuras
import qualified Data.Map as Map
mapa1 = Map.fromList [("a", 1), ("b", 2)]
mapa2 = Map.insert "c" 3 mapa1  -- mapa1 permanece intacto

-- Todas las funciones están currificadas
sumar :: Int -> Int -> Int -> Int
sumar x y z = x + y + z

sumar3 = sumar 3      -- Int -> Int -> Int
sumar3y5 = sumar3 5   -- Int -> Int
resultado = sumar3y5 7 -- 15

-- Composición elegante
procesamiento = map ((*2) . (+1)) [1..5]  -- [4,6,8,10,12]