I Programación funcional básica con Haskell 98 1

Índice General Prólogo Convenios i xxiii I Programación funcional básica con Haskell 98 1 0 Programación funcional 3 0.0 Funciones............................... 3 0.1 Sesiones y declaraciones....................... 4 0.2 Reducción de expresiones...................... 6 0.2.0 Órdenes de reducción aplicativo y normal......... 9 0.2.1 Evaluación perezosa..................... 10 0.3 Sobre Haskell............................ 11 1 Introducción a Haskell 13 1.0 El lenguaje Haskell......................... 13 1.1 Tipos simples predefinidos...................... 15 1.1.0 El tipo Bool......................... 15 1.1.1 El tipo Int.......................... 16 1.1.2 El tipo Integer........................ 17 1.1.3 El tipo F loat......................... 17 1.1.4 El tipo Double........................ 18 1.1.5 El tipo Char......................... 18 1.1.6 Operadores de igualdad y orden.............. 19 1.2 Constructores de tipo predefinidos................. 21 1.2.0 Tuplas............................. 21 1.2.1 Listas............................. 21 1.2.2 El constructor de tipo ( )................. 23 1.3 Comentarios.............................. 24 1.4 Operadores.............................. 25 1.4.0 Operadores frente a funciones................ 28 1.5 Comparación de Patrones...................... 29 1.5.0 Patrones constantes..................... 30 1.5.1 Patrones para listas..................... 33 1.5.2 Patrones para tuplas..................... 34 ix

x ÍNDICE GENERAL 1.5.3 Patrones aritméticos..................... 35 1.5.4 Patrones nombrados o seudónimos............. 36 1.5.5 El patrón subrayado..................... 37 1.5.6 Errores comunes....................... 37 1.5.7 Patrones y evaluación perezosa............... 38 1.6 Expresiones case........................... 39 1.7 La función error........................... 39 1.8 Funciones a trozos.......................... 40 1.9 Expresiones condicionales...................... 41 1.10 Definiciones locales.......................... 42 1.11 Expresiones lambda......................... 44 1.12 Sangrado............................... 45 1.13 Ámbitos y módulos.......................... 47 1.14 Ejercicios............................... 48 2 Funciones de orden superior y polimorfismo 51 2.0 Parcialización............................. 51 2.0.0 Aplicación parcial...................... 53 2.0.1 Secciones........................... 56 2.0.2 Funciones de orden superior................. 58 2.0.3 Funciones de orden superior sobre enteros......... 60 2.1 Polimorfismo............................. 62 2.1.0 La composición de funciones................ 65 2.1.1 Otras funciones polimórficas................. 68 2.1.2 Polimorfismo en listas.................... 69 2.1.3 Polimorfismo en tuplas.................... 72 2.1.4 Un iterador polimórfico sobre los naturales........ 73 3 Definiciones de tipo 75 3.0 Sinónimos de tipo.......................... 75 3.1 Definiciones de tipos de datos.................... 76 3.1.0 Tipos enumerados...................... 76 3.1.1 Uniones............................ 77 3.1.2 Productos........................... 78 3.1.3 Tipos recursivos....................... 83 3.1.4 Tipos Parametrizados (o Polimórficos)........... 92 3.1.5 Definiciones newtype..................... 94 3.2 Propiedades de funciones...................... 95 3.3 Sobrecarga.............................. 102 3.3.0 Un ejemplo de sobrecarga.................. 104 3.4 Ejercicios............................... 105 4 El sistema de clases de Haskell 107 4.0 Tipos y clases de tipos. Jerarquía de clases............ 107 4.0.0 El sistema de clases..................... 107 4.0.1 Declaración de clases..................... 110 4.0.2 La clase Eq de Prelude.................. 114 4.1 Contextos............................... 115

ÍNDICE GENERAL xi 4.1.0 Instancias paramétricas................... 118 4.2 Subclases. La clase Ord de Prelude................ 118 4.2.0 Un ejemplo: los enteros módulo n.............. 121 4.2.1 Intersección de clases..................... 122 4.3 Visualizando y leyendo datos. Read y Show de Prelude.... 122 4.4 Las clases Num, Integral y F ractional de Prelude....... 126 4.4.0 Los tipos numéricos de Haskell............. 127 4.4.1 Ambigüedad en las constantes numéricas......... 128 4.4.2 Promoción numérica..................... 130 4.4.3 Ejemplo: los racionales como instancias genéricas..... 131 4.5 Ejercicios............................... 133 5 Programación con listas 135 5.0 El tipo lista.............................. 135 5.0.0 Secuencias aritméticas. La clase Enum.......... 136 5.1 Concatenación de listas....................... 138 5.2 Inducción sobre listas........................ 140 5.3 Selectores............................... 142 5.4 Emparejando listas.......................... 144 5.5 Aplicando una función a los elementos de una lista........ 145 5.6 Filtros................................. 147 5.7 Listas por comprensión........................ 148 5.7.0 Semántica de listas por comprensión............ 152 5.8 Plegado de listas........................... 153 5.8.0 foldr............................. 153 5.8.1 foldl.............................. 156 5.9 Ordenación de listas......................... 158 5.9.0 Ordenación por inserción.................. 158 5.9.1 Ordenación por mezcla.................... 160 5.9.2 Ordenación rápida...................... 162 5.10 Funciones combinatorias....................... 163 5.10.0 Los segmentos iniciales de una lista............. 163 5.10.1 Los segmentos de datos consecutivos de una lista..... 164 5.10.2 Permutaciones de una lista................. 165 5.11 Otras funciones predefinidas..................... 167 5.12 Ejercicios............................... 168 6 Entrada y salida 175 6.0 Operaciones de entrada y salida................... 175 6.0.0 El problema de la entrada y salida............. 175 6.0.1 El tipo IO.......................... 176 6.0.2 Excepciones.......................... 178 6.1 Un formateador de textos...................... 180 6.1.0 Una implementación ineficiente............... 181 6.1.1 Una implementación eficiente................ 183 6.1.2 Utilidades para el manejo de documentos......... 185 6.1.3 Una clase de tipos documentables............. 186

xii ÍNDICE GENERAL 6.1.4 Ejemplos........................... 187 II Programación avanzada 189 7 Evaluación perezosa. Redes de procesos 191 7.0 Evaluación perezosa......................... 191 7.0.0 Argumentos estrictos..................... 191 7.0.1 Procesando estructuras infinitas.............. 192 7.1 Listas parciales y listas infinitas................... 195 7.1.0 Aproximaciones o listas parciales.............. 195 7.1.1 Inducción sobre listas parciales............... 196 7.2 Procesando estructuras infinitas................... 198 7.2.0 La criba de Eratóstenes................... 198 7.2.1 La lista de factoriales.................... 199 7.2.2 Los números de Fibonacci.................. 199 7.2.3 El triángulo de Pascal.................... 200 7.2.4 Sucesiones contadoras. Una sucesión que se cuenta a sí misma............................. 201 7.2.5 Sucesiones de parejas contadoras.............. 204 7.3 Redes de procesos.......................... 205 7.3.0 Redes finitas de procesos.................. 208 7.3.1 La red que calcula el Triángulo de Pascal......... 209 7.3.2 La red que calcula la sucesión de números primos..... 210 7.3.3 Procesos con varias entradas................ 210 7.3.4 La lista de factoriales.................... 211 7.3.5 Generación de los números de Fibonacci con una red de procesos............................ 212 7.3.6 Sucesiones en general.................... 213 7.3.7 Los números de Hamming.................. 216 7.4 Interacción de procesos cliente-servidor............... 217 7.4.0 Patrones irrefutables y comparación postergada de patrones217 7.5 Ejercicios............................... 219 8 Programación con árboles y grafos 225 8.0 Árboles................................ 225 8.1 8.0.0 Funciones de orden superior sobre árboles......... 227 Árboles binarios........................... 228 8.1.0 Árboles binarios de búsqueda................ 229 8.1.1 Funciones de orden superior para árboles binarios..... 233 8.1.2 Inducción para árboles binarios............... 234 8.2 Arrays................................. 235 8.2.0 Una implementación ineficiente............... 236 8.2.1 Una implementación eficiente................ 237 8.3 Grafos y búsqueda en grafos..................... 239 8.3.0 Búsqueda en anchura y en profundidad.......... 240 8.3.1 Los grafos como instancias de una clase uniparamétrica. 241 8.4 Grafos con pesos........................... 245

ÍNDICE GENERAL xiii 8.4.0 Los grafos con pesos como instancias de clases biparamétricas245 8.4.1 Una clase Haskell para grafos con pesos......... 247 8.5 Ejercicios............................... 249 9 Programación modular y tipos abstractos de datos 257 9.0 Módulos................................ 257 9.1 Bibliotecas estandarizadas...................... 257 9.2 Declaraciones de módulos...................... 258 9.3 Importación.............................. 259 9.3.0 Importación cualificada................... 260 9.4 Tipos Abstractos de Datos...................... 261 9.5 Representación............................ 261 9.5.0 Representación con interfaz no sobrecargado....... 262 9.5.1 Representación con un interfaz sobrecargado....... 263 9.6 El TAD conjunto (Conjunto).................... 267 9.7 El TAD Lista Ordenada (OrdLista)................ 269 9.8 El TAD Diccionario (Diccionario)................. 270 9.9 Un índice KWIC (KeyWord In Context).............. 272 9.9.0 Datos del problema...................... 273 9.9.1 La función kwic....................... 274 9.9.2 Algunas funciones y sinónimos de tipos útiles....... 274 9.9.3 La función creanoclaves.................. 276 9.9.4 Modelo de datos para la resolución............. 277 9.9.5 La función kwic....................... 278 9.10 Ejercicios............................... 280 10 Programación con Mónadas 281 10.0 Concepto de mónada......................... 281 10.1 Clases de constructores de tipos................... 282 10.1.0 La clase F unctor....................... 282 10.1.1 La clase Monad....................... 285 10.1.2 La clase MonadP lus..................... 288 10.2 Interpretación de las propiedades.................. 289 10.2.0 Interpretación del operador (>>=)............. 292 10.3 Relación entre funtor y mónada................... 293 10.4 La notación do............................ 295 10.5 Ejemplos de mónadas........................ 298 10.5.0 La mónada identidad..................... 298 10.5.1 La mónada escritora..................... 299 10.5.2 La mónada lectora...................... 301 10.5.3 La mónada de transformadores de estado......... 303 10.5.4 La lista como mónada indeterminista............ 308 10.5.5 La mónada error....................... 309 10.5.6 Un evaluador monádico................... 310 10.6 Operaciones con mónadas...................... 313 10.6.0 Combinado mónadas..................... 313 10.6.1 Transformadores monádicos................. 315

xiv ÍNDICE GENERAL 10.7 Ejercicios............................... 319 III Aplicaciones 321 11 Algoritmos numéricos programados funcionalmente 323 11.0 Introducción.............................. 323 11.1 Búsqueda de puntos fijos....................... 323 11.2 Extrapolación por paso al límite.................. 326 11.3 Álgebra lineal numérica....................... 330 11.3.0 Arrays............................. 330 11.3.1 Listas de listas........................ 336 11.4 Series de potencias.......................... 338 11.5 Ejercicios............................... 340 12 Puzzles y solitarios 343 12.0 Algunos problemas combinatorios.................. 343 12.0.0 El producto máximo con un conjunto de dígitos...... 343 12.0.1 El problema de las vasijas.................. 344 12.0.2 El problema de los caníbales y los misioneros....... 346 12.0.3 El solitario de Abreu..................... 348 12.1 La sopa de letras........................... 350 12.1.0 Un esbozo de la solución................... 352 12.1.1 Buscando las apariciones de un palabra.......... 353 12.1.2 Movimiento de matrices y lecturas de líneas........ 354 12.2 El problema de las ocho reinas................... 357 12.2.0 Soluciones mediante listas por comprensión........ 357 12.2.1 Solución mediante búsqueda en grafos........... 360 12.2.2 Grafos acíclicos........................ 362 12.3 El problema del coloreado de mapas................ 363 12.3.0 Calculando los colores de los países fronterizos...... 363 12.3.1 Un algoritmo para colorear mapas............. 365 12.3.2 Coloreados con un número de colores mínimo....... 366 12.3.3 Es preferible empezar coloreando los países con más países fronterizos........................... 367 12.4 El problema generalizado de las torres de Hanoi.......... 368 12.4.0 Movimientos entre dos torres................ 368 12.4.1 Movimientos entre una torre y una configuración..... 369 12.5 Un puzzle con fichas......................... 372 12.5.0 Representación de huecos y fichas.............. 373 12.5.1 Estudio de movimientos de una ficha............ 373 12.5.2 Movimientos entre configuraciones............. 375 12.6 Programación funcional estilo Prolog............... 378 12.6.0 El problema de McCarthy.................. 380 12.7 Ejercicios............................... 388

ÍNDICE GENERAL xv 13 Analizadores 391 13.0 Analizadores y la clase Read..................... 391 13.0.0 Gramáticas y la notación BNF............... 392 13.0.1 El tipo ReadS......................... 393 13.0.2 La clase Read......................... 402 13.0.3 Un analizador para árboles binarios............ 403 13.0.4 Gramáticas recursivas por la izquierda........... 405 13.1 Analizadores monádicos....................... 406 13.1.0 Secuenciación......................... 407 13.1.1 Alternancia.......................... 408 13.1.2 Filtros............................. 409 13.1.3 Iteración............................ 410 13.1.4 Elección parcial........................ 411 13.1.5 Un analizador para términos................ 412 13.2 Ejercicios............................... 414 14 Simulación 417 14.0 Generación de aleatorios por congruencias............. 417 14.0.0 Programando secuencias pseudo aleatorias........ 418 14.0.1 Algunos resultados teóricos................. 421 14.1 Simulación en el juego del poker.................. 422 14.1.0 Generando un mazo de cartas................ 423 14.1.1 Búsqueda de ciertas jugadas: parejas, tríos, etc....... 423 14.1.2 Contando todas las jugadas................. 424 14.2 Obteniendo semillas y aleatorios a través del sistema....... 427 14.2.0 Un modelo monádico para la simulación.......... 429 14.3 El juego de la lotería primitiva................... 431 14.3.0 Realizando escrutinios.................... 431 14.3.1 Generación de sorteos.................... 432 14.3.2 Estudio estadístico de ciertas combinaciones........ 433 14.3.3 Descripción monádica del juego de la primitiva...... 435 14.4 Simulación monádica de juegos con dados............. 436 14.4.0 Mezclando valores producidos por varias acciones..... 437 14.4.1 Plegando valores monádicos................. 438 14.4.2 Repetición de varias tiradas con varios dados....... 439 14.4.3 Contabilizando jugadas................... 441 IV Aspectos teóricos 443 15 Técnicas de programación y transformaciones de programas 445 15.0 Inducción estructural......................... 445 15.1 Parámetros acumuladores...................... 453 15.1.0 Los números de Fibonacci.................. 453 15.1.1 Cálculo del factorial de un natural............. 458 15.1.2 Plegados estrictos...................... 462 15.2 Transformación de programas. El modelo desplegar/plegar.... 465 15.2.0 Un ejemplo sencillo de transformación........... 465

xvi ÍNDICE GENERAL 15.2.1 Las reglas desplegar/plegar................. 466 15.2.2 Reducción de la complejidad por transformación..... 468 15.2.3 Corrección parcial de los programas transformados.... 475 15.3 Programas a partir de especificaciones............... 475 15.3.0 Especificaciones ejecutables................. 475 15.3.1 Especificaciones no ejecutables............... 476 15.3.2 Transformación de una especificación no ejecutable.... 477 15.4 Semántica denotacional de un lenguaje imperativo........ 480 15.4.0 Representación de entornos con tuplas........... 481 15.4.1 Representación de entornos con funciones......... 483 15.4.2 El lenguaje imperativo de Dijkstra............. 486 15.4.3 Una semántica determinista para el lenguaje de Dijkstra 489 15.4.4 Una semántica indeterminista para el lenguaje de Dijkstra 491 15.5 Ejercicios............................... 493 16 Introducción al λ cálculo 501 16.0 Sintaxis del lambda cálculo..................... 501 16.1 δ reducción y β reducción...................... 503 16.1.0 λ teorías........................... 507 16.1.1 Eta conversión y extensionalidad.............. 509 16.1.2 Reducción generada por un programa........... 510 16.2 Formas normales. Teoremas de Church Rosser.......... 512 16.3 Ordenes de reducción. Teorema de estandarización........ 515 16.4 Lambda definibilidad......................... 518 16.4.0 Operaciones lógicas...................... 519 16.4.1 Computabilidad....................... 519 16.4.2 Puntos fijos y recursión................... 521 16.4.3 Listas en el λc........................ 523 16.5 Los sistemas de tipos de Church y de Curry............ 524 16.5.0 Propiedades del sistema λ Curry............. 525 16.5.1 La correspondencia de Howard Curry de Bruijn..... 528 16.6 Ejemplos prácticos de inferencia de tipos.............. 528 16.6.0 Caso de un único argumento................ 530 16.6.1 Caso de varios argumentos................. 531 16.6.2 Caso en que aparecen otras variables predefinidas..... 533 16.7 Inferencia de tipos en presencia de recursión............ 535 16.8 Inferencia de tipos en presencia de patrones............ 538 16.9 Reglas elementales para inferencia de tipos............ 540 16.10El λ cálculo polimórfico....................... 543 16.10.0 Inferencia de tipos en presencia de polimorfismo..... 544 16.10.1 Un teorema de parametricidad para funciones polimórficas 546 V Ejercicios de Exámenes, Ayudas a Ejercicios y Soluciones 549 17 Ejercicios de Exámenes 551 17.0 Año 1996............................... 551

ÍNDICE GENERAL xvii 17.1 Año 1997............................... 558 17.2 Año 1998............................... 566 17.3 Año 1999............................... 574 17.4 Año 2000............................... 590 18 Soluciones a los Ejercicios de Exámenes 601 18.0 Año 1996............................... 601 18.1 Año 1997............................... 610 18.2 Año 1998............................... 619 18.3 Año 1999............................... 630 18.4 Año 2000............................... 655 19 Ayudas a Ejercicios Seleccionados 665 19.0 Introducción a Haskell....................... 665 19.1 Definiciones de tipo.......................... 665 19.2 El sistema de clases de Haskell.................. 666 19.3 Programación con listas....................... 667 19.4 Evaluación perezosa. Redes de procesos.............. 671 19.5 Programación con árboles y grafos................. 674 19.6 Algoritmos numéricos programados funcionalmente........ 674 19.7 Puzzles y solitarios.......................... 675 19.8 Analizadores............................. 681 19.9 Simulación............................... 683 19.10Técnicas de Programación y Transformaciones de programas.. 683 19.11Introducción al λ-cálculo....................... 687 20 Soluciones a Ejercicios 689 20.0 Introducción a Haskell....................... 689 20.1 Definiciones de tipo.......................... 692 20.2 El sistema de clases de Haskell.................. 695 20.3 Programación con listas....................... 698 20.4 Evaluación perezosa. Redes de procesos.............. 718 20.5 Programación con árboles y grafos................. 740 20.6 Programación con Mónadas..................... 749 20.7 Algoritmos numéricos programados funcionalmente........ 751 20.8 Puzzles y solitarios.......................... 757 20.9 Analizadores............................. 781 20.10Simulación............................... 785 20.11Técnicas de Programación y Transformaciones de programas.. 787 20.12Introducción al λ cálculo...................... 818 Referencias bibliográficas 823