Temario curso

Sección 1: Introducción a la programación funcional

• Comprender los beneficios de la programación funcional.
  • Un programa con efectos secundarios.
  • Una solución funcional: eliminar los efectos secundarios.
• ¿Qué es exactamente una función (pura)?
• Transparencia referencial, pureza y modelo de sustitución.

• Introducción el lenguaje Scala.
• Objetos y espacios de nombres.
• Funciones de orden superior: Pasar funciones a funciones.
  • Un pequeño desvío: escribir bucles funcionalmente.
  • Escribiendo nuestra primera función de orden superior.
• Funciones polimórficas: abstracción sobre tipos.
  • Un ejemplo de una función polimórfica.
  • Llamar a funciones de orden superior con funciones anónimas.
• Siguientes tipos a implementaciones.

• Definición de estructuras de datos funcionales.
• Coincidencia de patrones.
• Intercambio de datos en estructuras de datos funcionales.
  • La eficiencia del intercambio de datos.
  • Recursión sobre listas y generalización a funciones de orden superior.
  • Más funciones para trabajar con listas.
  • Pérdida de eficiencia al ensamblar funciones de lista a partir de componentes más simples.
• Árboles.

• Los aspectos buenos y malos de las excepciones.
• Posibles alternativas a las excepciones.
• El tipo de datos Opción.
  • Patrones de uso de Option.
  • Composición, elevación y ajuste de opciones API orientadas a excepciones.
• El tipo de datos Cualquiera.
  • Acumulación de errores.
  • Extracción de un tipo validado.

• Funciones estrictas y no estrictas.
• Listas diferidas: Un ejemplo extendido.
  • Memorizar listas perezosas y evitar el recálculo.
  • Funciones auxiliares para inspeccionar listas diferidas.
• Separar la descripción del programa de la evaluación.
• Listas infinitas de perezosos y corcursión.

• Generar números aleatorios utilizando efectos secundarios.
• Generación de números aleatorios puramente funcional.
• Hacer que las API con estado sean puras.
• Una mejor API para acciones de estado.
  • Combinación de acciones estatales.
  • Acciones de estado de anidamiento.
• Un tipo de datos de acción de estado general.
• Programación imperativa puramente funcional.

Sección 2: Diseño funcional y bibliotecas combinadoras

• Elegir tipos de datos y funciones.
  • Un tipo de datos para cálculos paralelos.
  • Combinación de cálculos paralelos.
  • Bifurcación explícita.
• Elegir una representación.
  • Refinar la API.
• El álgebra de una API.
  • La ley de mapeo.
  • La ley de la bifurcación.
  • Infringir la ley: Un error sutil.
  • Una implementación de Par totalmente sin bloqueo utilizando actores.
• Refinar los combinadores a su forma más general.

• Un breve recorrido por las pruebas basadas en propiedades.
  • Elegir tipos de datos y funciones.
  • Fragmentos iniciales de una API.
  • El significado y la API de las propiedades.
  • El significado y la API de los generadores.
  • Generadores que dependen de los valores generados.
  • Refinar el tipo de datos Prop.
• Minimización de casos de prueba.
  • Usar la biblioteca y mejorar su usabilidad.
  • Algunos ejemplos simples.
  • Escribir un conjunto de pruebas para cálculos paralelos.
• Prueba de funciones de orden superior y direcciones futuras.
• Las leyes de los generadores.

• Diseñar un álgebra primero.
• Un álgebra posible.
  • Repetición de corte y no vacía.
• Manejo de la sensibilidad al contexto.
• Escribir un analizador JSON.
  • El formato JSON.
  • Un analizador JSON.
• Informe de errores.
  • Un posible diseño.
  • Error de anidamiento.
  • Control de ramificación y retroceso.
• Implementación del álgebra.
  • Una posible implementación.
  • Analizadores de secuenciación.
  • Analizadores de etiquetado.
  • Conmutación por error y retroceso.
  • Análisis sensible al contexto.

Sección 3: Estructuras comunes en el diseño funcional

• ¿Qué es un monoide?
• Listas plegables con monoides.
• Asociatividad y paralelismo.
• Ejemplo: Análisis paralelo.
• Clases de tipo.
• Estructuras de datos plegables.
• Composición de monoides.
  • Ensamblando monoides más complejos.
  • Uso de monoides compuestos para fusionar recorridos.

• Funtores: Generalización de la función de mapa.
  • Leyes de funtores.
• Mónadas: Generalización de las funciones flatMap y unit.
  • El rasgo de la Mónada.
• Combinadores monádicos.
• Leyes de mónadas.
  • La ley asociativa.
  • Probar la ley asociativa para una mónada específica.
  • Las leyes de identidad.
• ¿Qué es una mónada?
  • La mónada de identidad.
  • La mónada estatal y la aplicación de tipo parcial.

• Mónadas generalizadoras.
• The Applicative trait.
• La diferencia entre mónadas y funtores aplicativos.
  • El aplicativo de opción frente a la mónada de opción.
  • El aplicativo del analizador versus la mónada del analizador.
• Las ventajas de los funtores aplicativos.
  • No todos los funtores aplicativos son mónadas.
• Las leyes aplicables.
  • Identidad de izquierda y derecha.
  • Asociatividad.
  • Naturalidad del producto.
• Funtores transitables.
• Usos de Traverse.
  • Desde monoides hasta funtores aplicativos.
  • Viajes con Estado.
  • Combinación de estructuras transitables.
  • Fusión transversal.
  • Recorridos anidados.
  • Composición de la mónada.

Sección 4: Efectos y E/S

• Efectos de factorización.
• Un tipo 10 simple.
  • Manejo de efectos de entrada.
  • Ventajas e inconvenientes del tipo lO simple.
• Evitar el StackOverflowError.
  • Reificar el flujo de control como constructores de datos.
  • Trampolín: Una solución general para el desbordamiento de pilas.
• Un tipo de E/S más matizado.
  • Mónadas libres.
  • Una mónada que solo admite E/S de consola.
  • Intérpretes puros.
• E/S asincrónicas y sin bloqueo.
  • Composición de álgebras libres.
• Capacidades.
• Un tipo de E/S de uso general.
  • El programa principal en el fin del universo.
• Por qué el tipo de E/S es insuficiente para la E/S de transmisión.

• Estado mutable puramente funcional.
• Un tipo de datos para hacer cumplir el alcance de los efectos secundarios.
  • Un poco de lenguaje para la mutación con alcance.
  • Un álgebra de referencias mutables.
  • Ejecución de acciones de estado mutables.
  • Matrices mutables.
  • Un quicksort in situ puramente funcional.
• La pureza es contextual.
  • ¿Qué cuenta como efecto secundario?

• Problemas con E/S imperativas: Un ejemplo.
• Transformaciones de flujo simples.
  • Creando tirones.
  • Composición de transformaciones de flujo.
  • Procesamiento de archivos.
• Extracciones y flujos extensibles.
  • Cálculos de transmisión efectivos.
  • Manejo de errores.
  • Garantizar la seguridad de los recursos.
  • Asignación dinámica de recursos.
• Aplicaciones.