Lenguajes y Fundamentos de Programación · LNG-230

Haskell y programación funcional pura

Evaluación perezosa, tipos algebraicos y mónadas explicadas con código ejecutable y sin misticismo.

Próximamente Avanzado 8 módulos · 38 clases

Formato asíncrono Desarrollo Haskell, JupyterLab

DESARROLLO JUPYTER

Lo que aprenderás

Escribir funciones puras aplicando currificación, composición de funciones y aplicación parcial de argumentos
Modelar dominios con tipos algebraicos, registros y coincidencia de patrones
Razonar sobre evaluación perezosa, thunks y estructuras infinitas sin agotar memoria
Leer y escribir firmas con clases de tipos, restricciones y polimorfismo paramétrico
Encadenar cómputos con Functor, Applicative y Monad en Maybe, Either y listas
Separar efectos con la mónada IO y construir programas ejecutables con Stack
Probar propiedades del código con QuickCheck en lugar de casos aislados

Contenido del curso

8 módulos · 38 clases en vídeo · práctica guiada en cada módulo

Módulo 1 · Presentación y entorno 4 clases

Qué aporta Haskell y qué exige a cambio
GHCi y prácticas en JupyterLab desde el navegador
Proyecto local con Stack o Cabal
Primeras funciones y lectura de errores del compilador

Módulo 2 · Funciones, tipos y patrones 5 clases

Tipos básicos, inferencia y firmas explícitas
Coincidencia de patrones y guardas
Recursión y funciones sobre listas
Currificación, composición y aplicación parcial
Ejercicio: reimplementar map, filter y foldr

Módulo 3 · Tipos algebraicos propios 5 clases

data, constructores y suma de tipos
Registros y actualización de campos
Maybe y Either para representar ausencia y error
newtype y tipos con significado propio
Ejercicio: modelar un catálogo de piezas

Módulo 4 · Clases de tipos 5 clases

Eq, Ord, Show y deriving
Definir una clase de tipos propia
Semigroup y Monoid con ejemplos de agregación
Foldable y Traversable en la práctica
Leer una firma con varias restricciones

Módulo 5 · Evaluación perezosa 5 clases

Thunks, forma normal y evaluación bajo demanda
Listas infinitas y flujos de datos
Fugas de memoria por acumulación de thunks
Forzado con seq y anotaciones de rigurosidad
Medir con el perfilador de GHC

Módulo 6 · Functor, Applicative y Monad 5 clases

Functor: aplicar una función dentro de un contexto
Applicative y combinación de valores independientes
Monad como encadenado de cómputos con contexto
Notación do y su traducción a bind
Mónadas State y Reader en un caso práctico

Módulo 7 · Efectos y pruebas 4 clases

La mónada IO y la frontera con el mundo exterior
Argumentos, ficheros y salida por consola
Pruebas basadas en propiedades con QuickCheck
Organizar un proyecto con Stack y sus dependencias

Módulo 8 · Proyecto de cierre 5 clases

Especificación de un analizador de ficheros de configuración
Tipos del árbol sintáctico y errores de análisis
Combinadores de análisis escritos desde cero
Programa ejecutable y pruebas de propiedades
Repaso general y rutas de continuación

Requisitos

Experiencia previa programando en cualquier lenguaje y soltura con la recursión
Conocer tipos genéricos o plantillas ayuda, aunque se repasa lo necesario
Basta con un navegador para las primeras prácticas en JupyterLab con kernel de Haskell

Descripción

Las ideas funcionales aparecen ya en casi todos los lenguajes: inmutabilidad, funciones de orden superior, tipos opcionales. Aprenderlas a trozos deja huecos, y conceptos como mónada quedan reducidos a una metáfora confusa. Haskell obliga a entenderlas de verdad porque el compilador no deja pasar los atajos, y eso convierte el lenguaje en el mejor sitio para asentarlas.

El curso avanza en pasos cortos y siempre con código ejecutable: primero funciones y tipos propios, después clases de tipos y el porqué de cada restricción en las firmas, y por último los efectos. Las mónadas se introducen resolviendo problemas concretos, encadenando cálculos que pueden fallar o que arrastran contexto, hasta llegar a un analizador de ficheros de configuración escrito desde cero.

Quien termina puede leer bibliotecas publicadas en Hackage, aplicar el razonamiento por tipos en su lenguaje habitual de trabajo y afrontar Scala, Rust, Elm o F# con otra mirada, reconociendo de dónde vienen sus construcciones. También abre paso a temas de especialización como los transformadores de mónadas, los tipos avanzados y el diseño de compiladores e intérpretes.

¿Para quién es este curso?

Desarrolladores con experiencia que quieren fundamentar las ideas funcionales que ya usan a medias
Personas que trabajan con Scala, Rust o TypeScript y necesitan entender tipos y efectos a fondo
Perfiles interesados en compiladores, analizadores y lenguajes específicos de dominio