Programación funcional

Las funciones de orden superior son funciones que pueden tomar otras funciones como argumentos o devolverlas como resultados. En cálculo, un ejemplo de una función de orden superior es el operador diferencial.${\displaystyle d/dx}$, que devuelve la derivada de una función${\displaystyle f}$.

Las funciones de orden superior están estrechamente relacionadas con las funciones de primera clase , ya que ambas permiten que las funciones actúen como argumentos y resultados de otras funciones. La distinción entre ambas es sutil: "orden superior" describe un concepto matemático de funciones que operan sobre otras funciones, mientras que "primera clase" es un término informático que se refiere a entidades de lenguajes de programación cuyo uso no tiene restricciones (por lo tanto, las funciones de primera clase pueden aparecer en cualquier parte del programa donde puedan aparecer otras entidades de primera clase, como los números, incluyendo como argumentos de otras funciones y como sus valores de retorno).

Las funciones de orden superior permiten la aplicación parcial o currificación , una técnica que aplica una función a sus argumentos uno a uno, de modo que cada aplicación devuelve una nueva función que acepta el siguiente argumento. Esto permite al programador expresar de forma concisa, por ejemplo, la función sucesora como el operador de suma aplicado parcialmente al número natural uno.

Las funciones (o expresiones) puras no tienen efectos secundarios (memoria o E/S). Esto significa que las funciones puras tienen varias propiedades útiles, muchas de las cuales se pueden usar para optimizar el código:

• Si el resultado de una expresión pura no se utiliza, se puede eliminar sin afectar a otras expresiones.
• Si se llama a una función pura con argumentos que no producen efectos secundarios, el resultado es constante con respecto a esa lista de argumentos (lo que a veces se denomina transparencia referencial o idempotencia ); es decir, al volver a llamar a la función pura con los mismos argumentos se obtiene el mismo resultado. (Esto puede permitir optimizaciones de caché como la memorización ).
• Si no existe dependencia de datos entre dos expresiones puras, su orden puede invertirse o pueden ejecutarse en paralelo y no pueden interferir entre sí (en otras palabras, la evaluación de cualquier expresión pura es segura para subprocesos ).
• Si el lenguaje completo no permite efectos secundarios, entonces se puede utilizar cualquier estrategia de evaluación; esto le da al compilador la libertad de reordenar o combinar la evaluación de expresiones en un programa (por ejemplo, utilizando la deforestación ).

Si bien la mayoría de los compiladores para lenguajes de programación imperativos detectan funciones puras y realizan la eliminación de subexpresiones comunes para llamadas a funciones puras, no siempre pueden hacerlo para bibliotecas precompiladas, que generalmente no exponen esta información, lo que impide las optimizaciones que involucran esas funciones externas. Algunos compiladores, como gcc , agregan palabras clave adicionales para que un programador marque explícitamente las funciones externas como puras, para habilitar dichas optimizaciones. Fortran 95 también permite que las funciones se designen como puras . ^{[ 61 ]} C++11 agregó constexpruna palabra clave con semántica similar.

La iteración (bucle) en lenguajes funcionales se suele realizar mediante recursión . Las funciones recursivas se invocan a sí mismas, permitiendo que una operación se repita hasta alcanzar el caso base . En general, la recursión requiere mantener una pila , cuyo consumo de espacio es lineal con respecto a la profundidad de la recursión. Esto podría hacer que la recursión sea prohibitivamente costosa en comparación con los bucles imperativos. Sin embargo, una forma especial de recursión conocida como recursión de cola puede ser reconocida y optimizada por un compilador en el mismo código utilizado para implementar la iteración en lenguajes imperativos. La optimización de la recursión de cola puede implementarse, entre otros métodos, transformando el programa al estilo de paso de continuaciones durante la compilación.

El estándar del lenguaje Scheme requiere que las implementaciones admitan la recursión de cola adecuada, lo que significa que deben permitir un número ilimitado de llamadas de cola activas. ^{[ 62 ] [ 63 ]} La recursión de cola adecuada no es simplemente una optimización; es una característica del lenguaje que asegura a los usuarios que pueden usar la recursión para expresar un bucle y que hacerlo sería seguro para el espacio. ^{[ 64 ]} Además, contrariamente a su nombre, tiene en cuenta todas las llamadas de cola, no solo la recursión de cola. Si bien la recursión de cola adecuada generalmente se implementa convirtiendo el código en bucles imperativos, las implementaciones pueden implementarla de otras maneras. Por ejemplo, Chicken mantiene intencionalmente una pila y deja que la pila se desborde . Sin embargo, cuando esto sucede, su recolector de basura reclamará espacio nuevamente, ^{[ 65 ]} permitiendo un número ilimitado de llamadas de cola activas aunque no convierta la recursión de cola en un bucle.

Los patrones comunes de recursión pueden abstraerse mediante funciones de orden superior, siendo los catamorfismos y anamorfismos (o "pliegues" y "despliegues") los ejemplos más evidentes. Estos esquemas de recursión desempeñan un papel análogo al de las estructuras de control integradas, como los bucles en los lenguajes imperativos .

La mayoría de los lenguajes de programación funcional de propósito general permiten la recursión sin restricciones y son Turing completos , lo que hace que el problema de la parada sea indecidible , puede causar inconsistencias en el razonamiento ecuacional y, por lo general, requiere la introducción de inconsistencias en la lógica expresada por el sistema de tipos del lenguaje . Algunos lenguajes de propósito especial, como Rocq, solo permiten la recursión bien fundada y son fuertemente normalizadores (las computaciones no terminantes solo pueden expresarse con flujos infinitos de valores llamados codatos ). En consecuencia, estos lenguajes no son Turing completos y expresar ciertas funciones en ellos es imposible, pero aún pueden expresar una amplia clase de computaciones interesantes evitando los problemas introducidos por la recursión sin restricciones. La programación funcional limitada a la recursión bien fundada con algunas otras restricciones se denomina programación funcional total . ^{[ 66 ]}

Los lenguajes funcionales se pueden clasificar según utilicen evaluación estricta (estricta) o no estricta (perezosa) , conceptos que se refieren a cómo se procesan los argumentos de las funciones cuando se evalúa una expresión. La diferencia técnica radica en la semántica denotacional de las expresiones que contienen cálculos fallidos o divergentes. Bajo la evaluación estricta, la evaluación de cualquier término que contenga un subtérmino fallido falla. Por ejemplo, la instrucción de Python :

imprimir ( len ([ 2 + 1 , 3 * 2 , 1 / 0 , 5 - 4 ]))

La evaluación estricta falla debido a la división por cero en el tercer elemento de la lista. En la evaluación perezosa, la función `length` devuelve el valor 4 (es decir, el número de elementos en la lista), ya que su evaluación no intenta evaluar los términos que la componen. En resumen, la evaluación estricta siempre evalúa completamente los argumentos de la función antes de invocarla. La evaluación perezosa no evalúa los argumentos de la función a menos que sus valores sean necesarios para evaluar la llamada a la función en sí.

La estrategia de implementación habitual para la evaluación perezosa en lenguajes funcionales es la reducción de grafos . ^{[ 67 ]} La evaluación perezosa se utiliza por defecto en varios lenguajes funcionales puros, incluidos Miranda , Clean y Haskell .

Hughes (1984) defiende la evaluación perezosa como un mecanismo para mejorar la modularidad de los programas mediante la separación de responsabilidades , facilitando la implementación independiente de productores y consumidores de flujos de datos. ^{[ 2 ]} Launchbury (1993) describe algunas dificultades que introduce la evaluación perezosa, particularmente en el análisis de los requisitos de almacenamiento de un programa, y ​​propone una semántica operacional para ayudar en dicho análisis. ^{[ 68 ]} Harper (2009) propone incluir tanto la evaluación estricta como la perezosa en el mismo lenguaje, utilizando el sistema de tipos del lenguaje para distinguirlas. ^{[ 69 ]}

Especialmente desde el desarrollo de la inferencia de tipos de Hindley-Milner en la década de 1970, los lenguajes de programación funcional han tendido a usar el cálculo lambda tipado , rechazando todos los programas inválidos en tiempo de compilación y arriesgándose a errores de falsos positivos , en contraposición al cálculo lambda sin tipado , que acepta todos los programas válidos en tiempo de compilación y arriesgándose a errores de falsos negativos , utilizado en Lisp y sus variantes (como Scheme ), ya que rechazan todos los programas inválidos en tiempo de ejecución cuando la información es suficiente para no rechazar programas válidos. El uso de tipos de datos algebraicos facilita la manipulación de estructuras de datos complejas; la presencia de una fuerte verificación de tipos en tiempo de compilación hace que los programas sean más fiables en ausencia de otras técnicas de fiabilidad como el desarrollo guiado por pruebas , mientras que la inferencia de tipos libera al programador de la necesidad de declarar manualmente los tipos al compilador en la mayoría de los casos.

Algunos lenguajes funcionales orientados a la investigación, como Rocq , Agda , Cayenne y Epigram, se basan en la teoría de tipos intuicionista , que permite que los tipos dependan de los términos. Estos tipos se denominan tipos dependientes . Estos sistemas de tipos no tienen inferencia de tipos decidible y son difíciles de comprender y programar. ^{[ 70 ] [ 71 ] [ 72 ] [ 73 ]} Pero los tipos dependientes pueden expresar proposiciones arbitrarias en lógica de orden superior . Mediante el isomorfismo de Curry-Howard , los programas bien tipados en estos lenguajes se convierten en un medio para escribir demostraciones matemáticas formales a partir de las cuales un compilador puede generar código certificado . Si bien estos lenguajes son principalmente de interés en la investigación académica (incluidas las matemáticas formalizadas ), también han comenzado a utilizarse en ingeniería. Compcert es un compilador para un subconjunto del lenguaje C que está escrito en Rocq y verificado formalmente. ^{[ 74 ]}

Una forma limitada de tipos dependientes, denominados tipos de datos algebraicos generalizados (GADT), puede implementarse de manera que proporcione algunos de los beneficios de la programación con tipos dependientes, evitando al mismo tiempo la mayoría de sus inconvenientes. ^{[ 75 ]} Los GADT están disponibles en el Glasgow Haskell Compiler , en OCaml ^{[ 76 ]} y en Scala , ^{[ 77 ]} y se han propuesto como complementos para otros lenguajes, incluidos Java y C#. ^{[ 78 ]}

Los programas funcionales no contienen sentencias de asignación; es decir, el valor de una variable en un programa funcional nunca cambia una vez definida. Esto elimina cualquier posibilidad de efectos secundarios, ya que cualquier variable puede ser reemplazada por su valor real en cualquier punto de la ejecución. Por lo tanto, los programas funcionales son referencialmente transparentes. ^{[ 79 ]}

Consideremos la instrucción de asignación en Cx = x * 10 , que cambia el valor asignado a la variable x. Digamos que el valor inicial de xera 1, entonces dos evaluaciones consecutivas de la variable xproducen 10y 100respectivamente. Claramente, reemplazar x = x * 10con 10o 100le da al programa un significado diferente, por lo que la expresión no es referencialmente transparente. De hecho, las instrucciones de asignación nunca son referencialmente transparentes.

Ahora bien, consideremos otra función que sea transparente, ya que no modifica implícitamente la entrada x y, por lo tanto, no tiene efectos secundarios . Los programas funcionales utilizan exclusivamente este tipo de función y, por consiguiente, son referencialmente transparentes.intplusOne(intx){returnx+1;}

Las estructuras de datos puramente funcionales a menudo se representan de manera diferente a sus contrapartes imperativas . ^{[ 80 ]} Por ejemplo, el array con tiempos de acceso y actualización constantes es un componente básico de la mayoría de los lenguajes imperativos, y muchas estructuras de datos imperativas, como la tabla hash y el montón binario , se basan en arrays. Los arrays pueden reemplazarse por mapas o listas de acceso aleatorio, que admiten una implementación puramente funcional, pero tienen tiempos de acceso y actualización logarítmicos . Las estructuras de datos puramente funcionales tienen persistencia , una propiedad que mantiene las versiones anteriores de la estructura de datos sin modificar. En Clojure, las estructuras de datos persistentes se utilizan como alternativas funcionales a sus contrapartes imperativas. Los vectores persistentes, por ejemplo, utilizan árboles para la actualización parcial. Llamar al método `insert` dará como resultado la creación de algunos nodos, pero no de todos. ^{[ 81 ]}

Los siguientes dos ejemplos (escritos en Java ) logran el mismo efecto: multiplican todos los números pares de un array por 10 y los suman todos, almacenando la suma final en la variable result.

Bucle imperativo tradicional:

int [] numList = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }; int result = 0 ; for ( int i : numList ) { if ( i % 2 == 0 ) { result += i * 10 ; } }

Programación funcional con funciones de orden superior:

import java.util.Arrays ;int [ ] numList = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } ; int result = Arrays.stream ( numList ) .filter ( n - > n % 2 == 0 ) .map ( n - > n * 10 ) .reduce ( 0 , Integer :: sum ) ;

En ocasiones, las abstracciones que ofrece la programación funcional pueden conducir al desarrollo de un código más robusto que evita ciertos problemas que podrían surgir al construir sobre una gran cantidad de código imperativo complejo, como errores de desfase de uno (véase la décima regla de Greenspun ).

Hay tareas (por ejemplo, mantener el saldo de una cuenta bancaria) que a menudo parecen implementarse de forma más natural mediante el uso de estados. La programación funcional pura realiza estas tareas, así como las tareas de entrada/salida, como aceptar la entrada del usuario e imprimir en pantalla, de una manera diferente.

El lenguaje de programación funcional puro Haskell los implementa usando mónadas , derivadas de la teoría de categorías . ^{[ 82 ]} Las mónadas ofrecen una forma de abstraer ciertos tipos de patrones computacionales, incluyendo (pero no limitándose a) el modelado de computaciones con estado mutable (y otros efectos secundarios como E/S) de manera imperativa sin perder pureza. Si bien las mónadas existentes pueden ser fáciles de aplicar en un programa, con plantillas y ejemplos apropiados, a muchos estudiantes les resulta difícil entenderlas conceptualmente, por ejemplo, cuando se les pide que definan nuevas mónadas (lo cual a veces es necesario para ciertos tipos de bibliotecas). ^{[ 83 ]}

Los lenguajes funcionales también simulan estados pasando estados inmutables. Esto se puede lograr haciendo que una función acepte el estado como uno de sus parámetros y devuelva un nuevo estado junto con el resultado, dejando el estado anterior sin cambios. ^{[ 84 ]}

Los lenguajes funcionales impuros suelen incluir un método más directo para gestionar el estado mutable. Clojure , por ejemplo, utiliza referencias gestionadas que se pueden actualizar aplicando funciones puras al estado actual. Este enfoque permite la mutabilidad a la vez que promueve el uso de funciones puras como la forma preferida de expresar cálculos. ^{[ 85 ]}

Se han desarrollado métodos alternativos, como la lógica de Hoare y la unicidad, para rastrear los efectos secundarios en los programas. Algunos lenguajes de investigación modernos utilizan sistemas de efectos para hacer explícita la presencia de efectos secundarios. ^{[ 86 ]}

Los lenguajes de programación funcional suelen ser menos eficientes en su uso de CPU y memoria que los lenguajes imperativos como C y Pascal . ^{[ 87 ]} Esto se relaciona con el hecho de que algunas estructuras de datos mutables, como los arreglos, tienen una implementación muy sencilla utilizando el hardware actual. Los arreglos planos pueden ser accedidos de manera muy eficiente con CPUs con segmentación profunda, precargados eficientemente a través de cachés (sin búsqueda compleja de punteros ) o manejados con instrucciones SIMD. Tampoco es fácil crear sus contrapartes inmutables de propósito general igualmente eficientes. Para los lenguajes puramente funcionales, la ralentización en el peor de los casos es logarítmica en el número de celdas de memoria utilizadas, porque la memoria mutable puede representarse mediante una estructura de datos puramente funcional con tiempo de acceso logarítmico (como un árbol balanceado). ^{[ 88 ]} Sin embargo, tales ralentizaciones no son universales. Para programas que realizan cálculos numéricos intensivos, los lenguajes funcionales como OCaml y Clean son solo ligeramente más lentos que C según The Computer Language Benchmarks Game . ^{[ 89 ]} Para programas que manejan matrices grandes y bases de datos multidimensionales , se diseñaron lenguajes funcionales de matrices (como J y K ) con optimizaciones de velocidad.

La inmutabilidad de los datos puede, en muchos casos, conducir a una mayor eficiencia de ejecución al permitir que el compilador haga suposiciones que no son seguras en un lenguaje imperativo, aumentando así las oportunidades de expansión en línea . ^{[ 90 ]} Aunque la copia involucrada, que puede parecer implícita al tratar con estructuras de datos persistentes e inmutables, pueda parecer computacionalmente costosa, algunos lenguajes de programación funcional, como Clojure, resuelven este problema implementando mecanismos para compartir memoria de forma segura entre datos formalmente inmutables . ^{[ 91 ]} Rust se distingue por su enfoque de la inmutabilidad de datos, que implica referencias inmutables ^{[ 92 ]} y un concepto llamado tiempos de vida. ^{[ 93 ]}

Los datos inmutables con separación de identidad y estado y esquemas sin recursos compartidos también pueden ser potencialmente más adecuados para la programación concurrente y paralela debido a la reducción o eliminación del riesgo de ciertos peligros de concurrencia, ya que las operaciones concurrentes suelen ser atómicas y esto permite eliminar la necesidad de bloqueos. Así es como java.util.concurrentse implementan, por ejemplo, las clases, donde algunas de ellas son variantes inmutables de las clases correspondientes que no son adecuadas para el uso concurrente. ^{[ 94 ]} Los lenguajes de programación funcional a menudo tienen un modelo de concurrencia que en lugar de estado compartido y sincronización, aprovecha mecanismos de paso de mensajes (como el modelo de actor , donde cada actor es un contenedor para el estado, el comportamiento, los actores hijos y una cola de mensajes). ^{[ 95 ] [ 96 ]} Este enfoque es común en Erlang / Elixir o Akka .

La evaluación perezosa también puede acelerar el programa, incluso asintóticamente, mientras que puede ralentizarlo como máximo por un factor constante (sin embargo, puede introducir fugas de memoria si se usa incorrectamente). Launchbury 1993 ^{[ 68 ]} analiza cuestiones teóricas relacionadas con las fugas de memoria de la evaluación perezosa, y O'Sullivan et al. 2008 ^{[ 97 ]} ofrecen algunos consejos prácticos para analizarlas y corregirlas. Sin embargo, las implementaciones más generales de evaluación perezosa que hacen un uso extensivo de código y datos desreferenciados tienen un rendimiento deficiente en procesadores modernos con tuberías profundas y cachés multinivel (donde un fallo de caché puede costar cientos de ciclos). ^{[ 98 ]}

(¿ igual? 5 ) ( .igual ( mod 5 2 ) 0 )

( defn even? "Devuelve verdadero si n es par, lanza una excepción si n no es un entero" { :added "1.0" :static true } [ n ] ( if ( integer? n ) ( zero? ( bit-and ( clojure.lang.RT/uncheckedLongCast n ) 1 )) ( throw ( IllegalArgumentException. ( str "El argumento debe ser un entero: " n )))))

Es posible utilizar un estilo de programación funcional en lenguajes que tradicionalmente no se consideran lenguajes funcionales. ^{[ 102 ]} Por ejemplo, tanto D ^{[ 103 ]} como Fortran 95 ^{[ 61 ]} admiten explícitamente funciones puras.

JavaScript , Lua , ^{[ 104 ]} Python y Go ^{[ 105 ]} tuvieron funciones de primera clase desde su inicio. ^{[ 106 ]} Python tuvo soporte para " lambda ", " map ", " reduce " y " filter " en 1994, así como cierres en Python 2.2, ^{[ 107 ]} aunque Python 3 relegó "reduce" al functoolsmódulo de la biblioteca estándar. ^{[ 108 ]} Las funciones de primera clase se han introducido en otros lenguajes principales como Perl 5.0 en 1994, PHP 5.3, Visual Basic 9 , C# 3.0, C++11 y Kotlin . ^{[ 28 ]}

En Perl, las expresiones lambda , map , reduce , filter y los cierres son totalmente compatibles y de uso frecuente. El libro Higher-Order Perl , publicado en 2005, se escribió para ofrecer una guía exhaustiva sobre el uso de Perl en la programación funcional.

En PHP, las clases anónimas , los cierres y las expresiones lambda son totalmente compatibles. Se están desarrollando bibliotecas y extensiones del lenguaje para estructuras de datos inmutables con el fin de facilitar la programación en el estilo funcional.

En Java , las clases anónimas a veces se pueden usar para simular cierres; ^{[ 109 ]} sin embargo, las clases anónimas no siempre son reemplazos adecuados para los cierres porque tienen capacidades más limitadas. ^{[ 110 ]} Java 8 admite expresiones lambda como reemplazo para algunas clases anónimas. ^{[ 111 ]}

En C# , las clases anónimas no son necesarias, ya que las clausuras y las expresiones lambda son totalmente compatibles. Se están desarrollando bibliotecas y extensiones del lenguaje para estructuras de datos inmutables con el fin de facilitar la programación funcional en C#.

Muchos patrones de diseño orientados a objetos se pueden expresar en términos de programación funcional: por ejemplo, el patrón de estrategia simplemente dicta el uso de una función de orden superior, y el patrón visitante se corresponde aproximadamente con un catamorfismo o plegado .

De manera similar, la idea de datos inmutables de la programación funcional se incluye a menudo en los lenguajes de programación imperativos, ^{[ 112 ]} por ejemplo la tupla en Python, que es un array inmutable, y Object.freeze() en JavaScript. ^{[ 113 ]}

Emacs , una familia de editores de texto altamente extensibles, utiliza su propio dialecto Lisp para escribir complementos. El autor original de la implementación más popular de Emacs, GNU Emacs y Emacs Lisp, Richard Stallman, considera a Lisp uno de sus lenguajes de programación favoritos. ^{[ 116 ]}

Las hojas de cálculo pueden considerarse una forma de sistema de programación funcional de evaluación estricta , de orden cero y pura. ^{[ 117 ]} Sin embargo, generalmente carecen de funciones de orden superior y de reutilización de código, y en algunas implementaciones, también carecen de recursión. Se han desarrollado varias extensiones para programas de hojas de cálculo con el fin de habilitar funciones de orden superior y reutilizables, pero hasta ahora siguen siendo principalmente de carácter académico. ^{[ 118 ]}

Debido a su capacidad de composición , los paradigmas de programación funcional pueden ser adecuados para arquitecturas basadas en microservicios . ^{[ 119 ]}

La programación funcional es un área de investigación activa en el campo de la teoría de lenguajes de programación . Existen varias publicaciones revisadas por pares centradas en la programación funcional, como la Conferencia Internacional sobre Programación Funcional , la Revista de Programación Funcional y el Simposio sobre Tendencias en Programación Funcional .

La programación funcional se ha empleado en una amplia gama de aplicaciones industriales. Por ejemplo, Erlang , que fue desarrollado por la empresa sueca Ericsson a finales de la década de 1980, se utilizó originalmente para implementar sistemas de telecomunicaciones tolerantes a fallos , ^{[ 11 ]} pero desde entonces se ha popularizado para construir una variedad de aplicaciones en empresas como Nortel , Facebook , Électricité de France y WhatsApp . ^{[ 10 ] [ 12 ] [ 120 ] [ 121 ] [ 122 ]} Scheme , un dialecto de Lisp , se utilizó como base para varias aplicaciones en las primeras computadoras Apple Macintosh ^{[ 3 ] [ 4 ]} y se ha aplicado a problemas como software de simulación de entrenamiento ^{[ 5 ]} y control de telescopios . ^{[ 6 ]} OCaml , que se introdujo a mediados de la década de 1990, ha tenido uso comercial en áreas como análisis financiero, ^{[ 14 ]} verificación de controladores , programación de robots industriales y análisis estático de software embebido . ^{[ 15 ]} Haskell , aunque inicialmente se concibió como un lenguaje de investigación, ^{[ 17 ]} también se ha aplicado en áreas como sistemas aeroespaciales, diseño de hardware y programación web. ^{[ 16 ] [ 17 ]}

Otros lenguajes de programación funcional que se han utilizado en la industria incluyen Scala , ^{[ 123 ]} F# , ^{[ 18 ] [ 19 ]} Wolfram Language , ^{[ 7 ]} Lisp , ^{[ 124 ]} Standard ML ^{[ 125 ] [ 126 ]} y Clojure . ^{[ 127 ]} Scala se ha utilizado ampliamente en ciencia de datos , ^{[ 128 ]} mientras que ClojureScript , ^{[ 129 ]} Elm ^{[ 130 ]} o PureScript ^{[ 131 ]} son ​​algunos de los lenguajes de programación funcional frontend utilizados en producción. El framework Phoenix de Elixir también es utilizado por algunos proyectos comerciales relativamente populares, como Font Awesome o la plataforma de anuncios clasificados Allegro Lokalnie de Allegro (una de las plataformas de comercio electrónico más grandes de Polonia) . ^{[ 132 ] [ 133 ]}

Las plataformas funcionales han sido populares en finanzas para el análisis de riesgos (especialmente en grandes bancos de inversión). Los factores de riesgo se codifican como funciones que forman grafos interdependientes (categorías) para medir correlaciones en los cambios del mercado, de manera similar a las optimizaciones de la base de Gröbner, pero también para marcos regulatorios como el Análisis y Revisión Integral de Capital . Dado el uso de OCaml y sus variantes en finanzas, estos sistemas a veces se consideran relacionados con una máquina abstracta categórica . La programación funcional está fuertemente influenciada por la teoría de categorías .

Muchas universidades imparten programación funcional. ^{[ 134 ] [ 135 ] [ 136 ] [ 137 ]} Algunas la tratan como un concepto de programación introductorio ^{[ 137 ]} mientras que otras primero enseñan métodos de programación imperativa. ^{[ 136 ] [ 138 ]}

Fuera de la informática, la programación funcional se utiliza para enseñar resolución de problemas, conceptos algebraicos y geométricos. ^{[ 139 ]} También se ha utilizado para enseñar mecánica clásica, como en el libro Estructura e interpretación de la mecánica clásica .

En particular, Scheme ha sido una opción relativamente popular para la enseñanza de la programación durante años. ^{[ 140 ] [ 141 ]}