Programación funcional

En informática , la programación funcional es un paradigma de programación en el que los

programas se construyen aplicando y componiendo funciones . Es un paradigma de programación
declarativa en el que las definiciones de funciones son árboles de expresiones que asignan valores
a otros valores, en lugar de una secuencia de declaraciones imperativas que actualizan el estado de
ejecución del programa.

En la programación funcional, las funciones se consideran ciudadanos de primera clase , lo que

significa que se pueden vincular a nombres (incluidos los identificadores locales ), pasar como
argumentos y devolver desde otras funciones, al igual que cualquier otro tipo de datos . Esto
permite escribir programas en un estilo declarativo y componible , donde las funciones pequeñas se
combinan de manera modular .

La programación funcional a veces se considera sinónimo de programación puramente funcional ,

un subconjunto de la programación funcional que trata todas las funciones como funciones
matemáticas deterministas o funciones puras . Cuando se llama a una función pura con algunos
argumentos dados, siempre devolverá el mismo resultado y no puede verse afectada por ningún
estado mutable u otros efectos secundarios . Esto contrasta con los procedimientos impuros ,
comunes en la programación imperativa , que pueden tener efectos secundarios (como modificar el
estado del programa o tomar la entrada de un usuario). Los defensores de la programación
puramente funcional afirman que al restringir los efectos secundarios, los programas pueden tener
menos errores , ser más fáciles de depurar y probar , y ser más adecuados para la verificación
formal . [ 1 ] [ 2 ]

La programación funcional tiene sus raíces en el ámbito académico , evolucionando a partir del
cálculo lambda , un sistema formal de computación basado únicamente en funciones. La
programación funcional ha sido históricamente menos popular que la programación imperativa,
pero muchos lenguajes funcionales se están utilizando hoy en día en la industria y la educación,
incluidos Common Lisp , Scheme , [ 3 ] [ 4 ] [ 5 ] [ 6 ] Clojure , Wolfram Language , [ 7 ] [ 8 ] Racket , [ 9 ]
Erlang , [ 10 ] [ 11 ] [ 12 ] Elixir , [ 13 ] OCaml , [ 14 ] [ 15 ] Haskell , [ 16 ] [ 17 ] y F# . [ 18 ] [ 19 ] Lean es un lenguaje
de programación funcional que se utiliza comúnmente para verificar teoremas matemáticos. [ 20 ] La
programación funcional también es clave para algunos lenguajes que han tenido éxito en dominios
específicos, como JavaScript en la Web, [ 21 ] R en estadística, [ 22 ] [ 23 ] J , K y Q en análisis financiero
y XQuery / XSLT para XML . [ 24 ] [ 25 ] Los lenguajes declarativos específicos de dominio como SQL y
Lex / Yacc utilizan algunos elementos de programación funcional, como no permitir valores
mutables . [ 26 ] Además, muchos otros lenguajes de programación admiten la programación en un
estilo funcional o han implementado características de la programación funcional, como C++11 , C#
, [ 27 ] Kotlin , [ 28 ] Perl , [ 29 ] PHP , [ 30 ] Python , [ 31 ] Go , [ 32 ] Rust , [ 33 ] Raku , [ 34 ] Scala , [ 35 ] y Java
(desde Java 8) . [ 36 ]

Historia

El cálculo lambda , desarrollado en la década de 1930 por Alonzo Church , es un sistema formal de
computación construido a partir de la aplicación de funciones . En 1937, Alan Turing demostró que
el cálculo lambda y las máquinas de Turing son modelos equivalentes de computación, [ 37 ]
mostrando que el cálculo lambda es Turing completo . El cálculo lambda forma la base de todos los
lenguajes de programación funcional. Una formulación teórica equivalente, la lógica combinatoria ,
fue desarrollada por Moses Schönfinkel y Haskell Curry en las décadas de 1920 y 1930. [ 38 ]

Posteriormente, Church desarrolló un sistema más débil, el cálculo lambda de tipos simples , que
extendió el cálculo lambda asignando un tipo de datos a todos los términos. [ 39 ] Esto constituye la
base para la programación funcional de tipos estáticos.

El primer lenguaje de programación funcional de alto nivel , Lisp , fue desarrollado a finales de los
años 1950 para la serie de ordenadores científicos IBM 700/7000 por John McCarthy mientras
estaba en el Instituto Tecnológico de Massachusetts (MIT). [ 40 ] Las funciones de Lisp se definieron
utilizando la notación lambda de Church, extendida con una construcción de etiquetas para permitir
funciones recursivas . [ 41 ] Lisp introdujo por primera vez muchas características paradigmáticas de
la programación funcional, aunque los primeros Lisp eran lenguajes multiparadigma e incorporaron
soporte para numerosos estilos de programación a medida que evolucionaban nuevos paradigmas.
Los dialectos posteriores, como Scheme y Clojure , y derivaciones como Dylan y Julia , buscaron
simplificar y racionalizar Lisp en torno a un núcleo funcional limpio, mientras que Common Lisp fue
diseñado para preservar y actualizar las características paradigmáticas de los numerosos dialectos
más antiguos que reemplazó. [ 42 ]

Information Processing Language (IPL), 1956, is sometimes cited as the first computer-based
functional programming language.[43] It is an assembly-style language for manipulating lists of
symbols. It does have a notion of generator, which amounts to a function that accepts a function as
an argument, and, since it is an assembly-level language, code can be data, so IPL can be regarded
as having higher-order functions. However, it relies heavily on the mutating list structure and similar
imperative features.

Kenneth E. Iverson developed APL in the early 1960s, described in his 1962 book A Programming
Language (ISBN 9780471430148). APL was the primary influence on John Backus's FP. In the early
1990s, Iverson and Roger Hui created J. In the mid-1990s, Arthur Whitney, who had previously
worked with Iverson, created K, which is used commercially in financial industries along with its
descendant Q.

In the mid-1960s, Peter Landin invented SECD machine,[44] the first abstract machine for a
functional programming language,[45] described a correspondence between ALGOL 60 and the
lambda calculus,[46][47] and proposed the ISWIM programming language.[48]

John Backus presented FP in his 1977 Turing Award lecture "Can Programming Be Liberated From
the von Neumann Style? A Functional Style and its Algebra of Programs".[49] He defines functional
programs as being built up in a hierarchical way by means of "combining forms" that allow an
"algebra of programs"; in modern language, this means that functional programs follow the principle
of compositionality. Backus's paper popularized research into functional programming, though it
emphasized function-level programming rather than the lambda-calculus style now associated with
functional programming.

The 1973 language ML was created by Robin Milner at the University of Edinburgh, and David Turner
developed the language SASL at the University of St Andrews. Also in Edinburgh in the 1970s,
Burstall and Darlington developed the functional language NPL.[50] NPL was based on Kleene
Recursion Equations and was first introduced in their work on program transformation.[51] Burstall,
MacQueen and Sannella then incorporated the polymorphic type checking from ML to produce the
language Hope.[52] ML eventually developed into several dialects, the most common of which are
now OCaml and Standard ML.

In the 1970s, Guy L. Steele and Gerald Jay Sussman developed Scheme, as described in the Lambda
Papers and the 1985 textbook Structure and Interpretation of Computer Programs. Scheme was the
first dialect of lisp to use lexical scoping and to require tail-call optimization, features that
encourage functional programming.

In the 1980s, Per Martin-Löf developed intuitionistic type theory (also called constructive type
theory), which associated functional programs with constructive proofs expressed as dependent
types. This led to new approaches to interactive theorem proving and has influenced the
development of subsequent functional programming languages.

The lazy functional language, Miranda, developed by David Turner, initially appeared in 1985 and had
a strong influence on Haskell. With Miranda being proprietary, Haskell began with a consensus in
1987 to form an open standard for functional programming research; implementation releases have
been ongoing as of 1990.
More recently it has found use in niches such as parametric CAD in the OpenSCAD language built on
the CGAL framework, although its restriction on reassigning values (all values are treated as
constants) has led to confusion among users who are unfamiliar with functional programming as a
concept.[53]

La programación funcional continúa utilizándose en entornos comerciales. [ 54 ] [ 55 ] [ 56 ]

Conceptos

Hay varios conceptos [ 57 ] y paradigmas que son específicos de la programación funcional y, por lo
general, ajenos a la programación imperativa (incluida la programación orientada a objetos ). Sin
embargo, los lenguajes de programación suelen adaptarse a varios paradigmas de programación,
por lo que los programadores que utilizan lenguajes "mayoritariamente imperativos" pueden haber
utilizado algunos de estos conceptos. [ 58 ]

Funciones de primera clase y de orden superior

Las funciones de orden superior son funciones que pueden tomar otras funciones como
argumentos o devolverlas como resultados. En cálculo, un ejemplo de función de orden superior es
el operador diferencial. , que devuelve la derivada de una función .

Las funciones de orden superior están estrechamente relacionadas con las funciones de primera
clase en el sentido de que tanto las funciones de orden superior como las de primera clase
permiten que las funciones sean argumentos y resultados de otras funciones. La distinción entre
ambas es sutil: "de orden superior" describe un concepto matemático de funciones que operan
sobre otras funciones, mientras que "de primera clase" es un término informático para las entidades
del lenguaje de programación que no tienen restricciones en su uso (por lo tanto, las funciones de
primera clase pueden aparecer en cualquier parte del programa en la que otras entidades de
primera clase, como los números, pueden hacerlo, incluso 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 la vez, y cada aplicación devuelve una nueva función
que acepta el siguiente argumento. Esto permite que un programador exprese de manera sucinta,
por ejemplo, la función sucesora como el operador de suma parcialmente aplicado al número
natural uno.
Funciones puras

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 utilizar
para optimizar el código:

Si no se utiliza el resultado de una expresión pura, se puede eliminar sin afectar a otras
expresiones.

If a pure function is called with arguments that cause no side-effects, the result is constant with
respect to that argument list (sometimes called referential transparency or idempotence), i.e.,
calling the pure function again with the same arguments returns the same result. (This can enable
caching optimizations such as memoization.)

If there is no data dependency between two pure expressions, their order can be reversed, or they
can be performed in parallel and they cannot interfere with one another (in other terms, the
evaluation of any pure expression is thread-safe).

If the entire language does not allow side-effects, then any evaluation strategy can be used; this
gives the compiler freedom to reorder or combine the evaluation of expressions in a program (for
example, using deforestation).

While most compilers for imperative programming languages detect pure functions and perform
common-subexpression elimination for pure function calls, they cannot always do this for pre-
compiled libraries, which generally do not expose this information, thus preventing optimizations
that involve those external functions. Some compilers, such as gcc, add extra keywords for a
programmer to explicitly mark external functions as pure, to enable such optimizations. Fortran 95
also lets functions be designated pure.[59] C++11 added constexpr keyword with similar
semantics.

Recursion

Iteration (looping) in functional languages is usually accomplished via recursion. Recursive

functions invoke themselves, letting an operation be repeated until it reaches the base case. In
general, recursion requires maintaining a stack, which consumes space in a linear amount to the
depth of recursion. This could make recursion prohibitively expensive to use instead of imperative
loops. However, a special form of recursion known as tail recursion can be recognized and
optimized by a compiler into the same code used to implement iteration in imperative languages.
Tail recursion optimization can be implemented by transforming the program into continuation
passing style during compiling, among other approaches.

The Scheme language standard requires implementations to support proper tail recursion, meaning
they must allow an unbounded number of active tail calls.[60][61] Proper tail recursion is not simply
an optimization; it is a language feature that assures users that they can use recursion to express a
loop and doing so would be safe-for-space.[62] Moreover, contrary to its name, it accounts for all tail
calls, not just tail recursion. While proper tail recursion is usually implemented by turning code into
imperative loops, implementations might implement it in other ways. For example, Chicken
intentionally maintains a stack and lets the stack overflow. However, when this happens, its garbage
collector will claim space back,[63] allowing an unbounded number of active tail calls even though it
does not turn tail recursion into a loop.

Common patterns of recursion can be abstracted away using higher-order functions, with
catamorphisms and anamorphisms (or "folds" and "unfolds") being the most obvious examples.
Such recursion schemes play a role analogous to built-in control structures such as loops in
imperative languages.

Most general purpose functional programming languages allow unrestricted recursion and are
Turing complete, which makes the halting problem undecidable, can cause unsoundness of
equational reasoning, and generally requires the introduction of inconsistency into the logic
expressed by the language's type system. Some special purpose languages such as Coq allow only
well-founded recursion and are strongly normalizing (nonterminating computations can be
expressed only with infinite streams of values called codata). As a consequence, these languages
fail to be Turing complete and expressing certain functions in them is impossible, but they can still
express a wide class of interesting computations while avoiding the problems introduced by
unrestricted recursion. Functional programming limited to well-founded recursion with a few other
constraints is called total functional programming.[64]

Strict versus non-strict evaluation

Functional languages can be categorized by whether they use strict (eager) or non-strict (lazy)
evaluation, concepts that refer to how function arguments are processed when an expression is
being evaluated. The technical difference is in the denotational semantics of expressions containing
failing or divergent computations. Under strict evaluation, the evaluation of any term containing a
failing subterm fails. For example, the expression:
 print length([2+1, 3*2, 1/0, 5-4])

fails under strict evaluation because of the division by zero in the third element of the list. Under lazy
evaluation, the length function returns the value 4 (i.e., the number of items in the list), since
evaluating it does not attempt to evaluate the terms making up the list. In brief, strict evaluation
always fully evaluates function arguments before invoking the function. Lazy evaluation does not
evaluate function arguments unless their values are required to evaluate the function call itself.

The usual implementation strategy for lazy evaluation in functional languages is graph reduction.[65]
Lazy evaluation is used by default in several pure functional languages, including Miranda, Clean,
and Haskell.

Hughes 1984 argues for lazy evaluation as a mechanism for improving program modularity through
separation of concerns, by easing independent implementation of producers and consumers of data
streams.[2] Launchbury 1993 describes some difficulties that lazy evaluation introduces, particularly
in analyzing a program's storage requirements, and proposes an operational semantics to aid in
such analysis.[66] Harper 2009 proposes including both strict and lazy evaluation in the same
language, using the language's type system to distinguish them.[67]

Type systems

Especially since the development of Hindley–Milner type inference in the 1970s, functional
programming languages have tended to use typed lambda calculus, rejecting all invalid programs at
compilation time and risking false positive errors, as opposed to the untyped lambda calculus, that
accepts all valid programs at compilation time and risks false negative errors, used in Lisp and its
variants (such as Scheme), as they reject all invalid programs at runtime when the information is
enough to not reject valid programs. The use of algebraic data types makes manipulation of
complex data structures convenient; the presence of strong compile-time type checking makes
programs more reliable in absence of other reliability techniques like test-driven development, while
type inference frees the programmer from the need to manually declare types to the compiler in
most cases.

Some research-oriented functional languages such as Coq, Agda, Cayenne, and Epigram are based
on intuitionistic type theory, which lets types depend on terms. Such types are called dependent
types. These type systems do not have decidable type inference and are difficult to understand and
program with.[68][69][70][71] But dependent types can express arbitrary propositions in higher-order
logic. Through the Curry–Howard isomorphism, then, well-typed programs in these languages
become a means of writing formal mathematical proofs from which a compiler can generate
certified code. While these languages are mainly of interest in academic research (including in
formalized mathematics), they have begun to be used in engineering as well. Compcert is a
compiler for a subset of the language C that is written in Coq and formally verified.[72]

A limited form of dependent types called generalized algebraic data types (GADT's) can be
implemented in a way that provides some of the benefits of dependently typed programming while
avoiding most of its inconvenience.[73] GADT's are available in the Glasgow Haskell Compiler, in
OCaml[74] and in Scala,[75] and have been proposed as additions to other languages including Java
and C#.[76]

Referential transparency

Functional programs do not have assignment statements, that is, the value of a variable in a
functional program never changes once defined. This eliminates any chances of side effects
because any variable can be replaced with its actual value at any point of execution. So, functional
programs are referentially transparent.[77]

Consider C assignment statement x=x*10 , this changes the value assigned to the variable x . Let
us say that the initial value of x was 1 , then two consecutive evaluations of the variable x yields
10 and 100 respectively. Clearly, replacing x=x*10 with either 10 or 100 gives a program a
different meaning, and so the expression is not referentially transparent. In fact, assignment
statements are never referentially transparent.

Now, consider another function such as int plusone(int x) {return x+1;} is

transparent, as it does not implicitly change the input x and thus has no such side effects.
Functional programs exclusively use this type of function and are therefore referentially transparent.

Data structures

Las estructuras de datos puramente funcionales suelen representarse de una manera diferente a
sus contrapartes imperativas . [ 78 ] Por ejemplo, la matriz 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 matrices.
Las matrices 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 de mantener
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. [ 79 ]

Comparación con la programación imperativa

La programación funcional es muy diferente de la programación imperativa . Las diferencias más

significativas surgen del hecho de que la programación funcional evita los efectos secundarios ,
que se utilizan en la programación imperativa para implementar el estado y la E/S. La programación
funcional pura evita por completo los efectos secundarios y proporciona transparencia referencial.

En la programación imperativa antigua, rara vez se utilizan funciones de orden superior. Un

programa imperativo tradicional podría utilizar un bucle para recorrer y modificar una lista. Por otro
lado, un programa funcional probablemente utilizaría una función de "mapa" de orden superior que
toma una función y una lista, generando y devolviendo una nueva lista aplicando la función a cada
elemento de la lista.

Programación imperativa vs. programación funcional

Los siguientes dos ejemplos (escritos en JavaScript ) logran el mismo efecto: multiplican todos los
números pares de una matriz por 10 y los suman todos, almacenando la suma final en la variable
"resultado".

Bucle imperativo tradicional:

const numList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

let result = 0;
for (let i = 0; i < numList.length; i++) {
if (numList[i] % 2 === 0) {
result += numList[i] * 10;
}
}

Functional programming with higher-order functions:

const result = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

.filter(n => n % 2 === 0)
 .map(a => a * 10)
.reduce((a, b) => a + b, 0);

Sometimes the abstractions offered by functional programming might lead to development of more
robust code that avoids certain issues that might arise when building upon large amount of
complex, imperative code, such as off-by-one errors (see Greenspun's tenth rule).

Simulating state

There are tasks (for example, maintaining a bank account balance) that often seem most naturally
implemented with state. Pure functional programming performs these tasks, and I/O tasks such as
accepting user input and printing to the screen, in a different way.

The pure functional programming language Haskell implements them using monads, derived from
category theory.[80] Monads offer a way to abstract certain types of computational patterns,
including (but not limited to) modeling of computations with mutable state (and other side effects
such as I/O) in an imperative manner without losing purity. While existing monads may be easy to
apply in a program, given appropriate templates and examples, many students find them difficult to
understand conceptually, e.g., when asked to define new monads (which is sometimes needed for
certain types of libraries).[81]

Functional languages also simulate states by passing around immutable states. This can be done
by making a function accept the state as one of its parameters, and return a new state together with
the result, leaving the old state unchanged.[82]

Impure functional languages usually include a more direct method of managing mutable state.
Clojure, for example, uses managed references that can be updated by applying pure functions to
the current state. This kind of approach enables mutability while still promoting the use of pure
functions as the preferred way to express computations.

Alternative methods such as Hoare logic and uniqueness have been developed to track side effects
in programs. Some modern research languages use effect systems to make the presence of side
effects explicit.

Efficiency issues

Functional programming languages are typically less efficient in their use of CPU and memory than
imperative languages such as C and Pascal.[83] This is related to the fact that some mutable data
structures like arrays have a very straightforward implementation using present hardware. Flat
arrays may be accessed very efficiently with deeply pipelined CPUs, prefetched efficiently through
caches (with no complex pointer chasing), or handled with SIMD instructions. It is also not easy to
create their equally efficient general-purpose immutable counterparts. For purely functional
languages, the worst-case slowdown is logarithmic in the number of memory cells used, because
mutable memory can be represented by a purely functional data structure with logarithmic access
time (such as a balanced tree).[84] However, such slowdowns are not universal. For programs that
perform intensive numerical computations, functional languages such as OCaml and Clean are only
slightly slower than C according to The Computer Language Benchmarks Game.[85] For programs
that handle large matrices and multidimensional databases, array functional languages (such as J
and K) were designed with speed optimizations.

Immutability of data can in many cases lead to execution efficiency by allowing the compiler to
make assumptions that are unsafe in an imperative language, thus increasing opportunities for
inline expansion.[86] Even if the involved copying that may seem implicit when dealing with
persistent immutable data structures might seem computationally costly, some functional
programming languages, like Clojure solve this issue by implementing mechanisms for safe
memory sharing between formally immutable data.[87] Rust distinguishes itself by its approach to
data immutability which involves immutable references[88] and a concept called lifetimes.[89]

Immutable data with separation of identity and state and shared-nothing schemes can also
potentially be more well-suited for concurrent and parallel programming by the virtue of reducing or
eliminating the risk of certain concurrency hazards, since concurrent operations are usually atomic
and this allows eliminating the need for locks. This is how for example java.util.concurrent
classes are implemented, where some of them are immutable variants of the corresponding classes
that are not suitable for concurrent use.[90] Functional programming languages often have a
concurrency model that instead of shared state and synchronization, leverages message passing
mechanisms (such as the actor model, where each actor is a container for state, behavior, child
actors and a message queue).[91][92] This approach is common in Erlang/Elixir or Akka.

Lazy evaluation may also speed up the program, even asymptotically, whereas it may slow it down
at most by a constant factor (however, it may introduce memory leaks if used improperly).
Launchbury 1993[66] discusses theoretical issues related to memory leaks from lazy evaluation, and
O'Sullivan et al. 2008[93] give some practical advice for analyzing and fixing them. However, the most
general implementations of lazy evaluation making extensive use of dereferenced code and data
perform poorly on modern processors with deep pipelines and multi-level caches (where a cache
miss may cost hundreds of cycles) .
Abstraction cost

Some functional programming languages might not optimize abstractions such as higher order
functions like "map" or "filter" as efficiently as the underlying imperative operations. Consider, as an
example, the following two ways to check if 5 is an even number in Clojure:

(even? 5)
(.equals (mod 5 2) 0)

When benchmarked using the Criterium (https://clojars.org/criterium) tool on a Ryzen 7900X

GNU/Linux PC in a Leiningen REPL 2.11.2, running on Java VM version 22 and Clojure version
1.11.1, the first implementation, which is implemented as:

(defn even?
"Returns true if n is even, throws an exception if n is not an
integer"
{:added "1.0"
:static true}
[n] (if (integer? n)
(zero? (bit-and (clojure.lang.RT/uncheckedLongCast n) 1))
(throw (IllegalArgumentException. (str "Argument must be an
integer: " n)))))

has the mean execution time of 4.76 ms, while the second one, in which .equals is a direct
invocation of the underlying Java method, has a mean execution time of 2.8 μs – roughly 1700
times faster. Part of that can be attributed to the type checking and exception handling involved in
the implementation of even? , so let's take for instance the lo library (https://github.com/samber/l
o) for Go, which implements various higher-order functions common in functional programming
languages using generics. In a benchmark provided by the library's author, calling map is 4% slower
than an equivalent for loop and has the same allocation profile,[94] which can be attributed to
various compiler optimizations, such as inlining.[95]

One distinguishing feature of Rust are zero-cost abstractions. This means that using them imposes
no additional runtime overhead. This is achieved thanks to the compiler using loop unrolling, where
each iteration of a loop, be it imperative or using iterators, is converted into a standalone Assembly
instruction, without the overhead of the loop controlling code. If an iterative operation writes to an
array, the resulting array's elements will be stored in specific CPU registers, allowing for constant-
time access at runtime.[96]
Functional programming in non-functional languages

It is possible to use a functional style of programming in languages that are not traditionally
considered functional languages.[97] For example, both D[98] and Fortran 95[59] explicitly support
pure functions.

JavaScript , Lua , [ 99 ] Python y Go [ 100 ] tuvieron funciones de primera clase desde su inicio. [ 101 ]
Python tuvo soporte para " lambda ", " map ", " reduce " y " filter " en 1994, así como cierres en
Python 2.2, [ 102 ] aunque Python 3 relegó "reduce" al functools módulo de biblioteca estándar.
[ 103 ]
Se han introducido funciones de primera clase en otros lenguajes principales como PHP 5.3,
Visual Basic 9 , C# 3.0, C++11 y Kotlin . [ 28 ]

En PHP, las clases anónimas , los cierres y las lambdas son totalmente compatibles. Se están
desarrollando bibliotecas y extensiones de 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; [ 104 ] sin embargo, las
clases anónimas no siempre son reemplazos adecuados para los cierres porque tienen
capacidades más limitadas. [ 105 ] Java 8 admite expresiones lambda como reemplazo para algunas
clases anónimas. [ 106 ]

En C# , las clases anónimas no son necesarias, ya que los cierres y las lambdas son totalmente
compatibles. Se están desarrollando bibliotecas y extensiones de lenguaje para estructuras de
datos inmutables con el fin de facilitar la programación en el estilo funcional de 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 de visitante corresponde aproximadamente a un catamorfismo o pliegue .

De manera similar, la idea de datos inmutables de la programación funcional a menudo se incluye

en lenguajes de programación imperativos, [ 107 ] por ejemplo, la tupla en Python, que es una matriz
inmutable, y Object.freeze() en JavaScript. [ 108 ]

Comparación con la programación lógica

Logic programming can be viewed as a generalisation of functional programming, in which

functions are a special case of relations.[109] For example, the function, mother(X) = Y, (every X has
only one mother Y) can be represented by the relation mother(X, Y). Whereas functions have a strict
input-output pattern of arguments, relations can be queried with any pattern of inputs and outputs.
Consider the following logic program:

mother(charles, elizabeth).
mother(harry, diana).

The program can be queried, like a functional program, to generate mothers from children:

?- mother(harry, X).
X = diana.
?- mother(charles, X).
X = elizabeth.

But it can also be queried backwards, to generate children:

?- mother(X, elizabeth).
X = charles.
?- mother(X, diana).
X = harry.

It can even be used to generate all instances of the mother relation:

?- mother(X, Y).
X = charles,
Y = elizabeth.
X = harry,
Y = diana.

Compared with relational syntax, functional syntax is a more compact notation for nested functions.
For example, the definition of maternal grandmother in functional syntax can be written in the
nested form:

maternal_grandmother(X) = mother(mother(X)).

The same definition in relational notation needs to be written in the unnested form:
 maternal_grandmother(X, Y) :- mother(X, Z), mother(Z, Y).

Here :- means if and , means and.

However, the difference between the two representations is simply syntactic. In Ciao Prolog,
relations can be nested, like functions in functional programming:[110]

abuelo ( a) ( X ) := padre ( a) ( padre ( a) (X )).

padre ( a ) (X ) := madre ( X ).
padre ( a) ( X ) := padre ( a) ( X ).

madre ( charles ) := elizabeth .

padre ( charles ) := phillip .
madre ( harry ) := diana .
padre ( harry ) := charles .

?- abuelo ( X , Y ).
X = harry ,
Y = elizabeth .
X = harry ,
Y = phillip .

Ciao transforma la notación funcional en forma relacional y ejecuta el programa lógico resultante
utilizando la estrategia de ejecución estándar de Prolog.

Aplicaciones

Editores de texto

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.
[ 111 ]

Helix , desde la versión 24.03, admite la vista previa de AST como S-expresiones , que también son
la característica principal de la familia de lenguajes de programación Lisp. [ 112 ]
Hojas de cálculo

Las hojas de cálculo pueden considerarse una forma de sistema de programación funcional puro,
de orden cero y de evaluación estricta. [ 113 ] Sin embargo, las hojas de cálculo generalmente
carecen de funciones de orden superior, así como 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 para habilitar funciones de orden superior y reutilizables, pero hasta
ahora siguen siendo principalmente de naturaleza académica. [ 114 ]

Microservicios

Debido a su componibilidad , los paradigmas de programación funcional pueden ser adecuados

para arquitecturas basadas en microservicios . [ 115 ]

Academia

Functional programming is an active area of research in the field of programming language theory.
There are several peer-reviewed publication venues focusing on functional programming, including
the International Conference on Functional Programming, the Journal of Functional Programming,
and the Symposium on Trends in Functional Programming.

Industry

Functional programming has been employed in a wide range of industrial applications. For example,
Erlang, which was developed by the Swedish company Ericsson in the late 1980s, was originally
used to implement fault-tolerant telecommunications systems,[11] but has since become popular for
building a range of applications at companies such as Nortel, Facebook, Électricité de France and
WhatsApp.[10][12][116][117][118] Scheme, a dialect of Lisp, was used as the basis for several
applications on early Apple Macintosh computers[3][4] and has been applied to problems such as
training-simulation software[5] and telescope control.[6] OCaml, which was introduced in the mid-
1990s, has seen commercial use in areas such as financial analysis,[14] driver verification, industrial
robot programming and static analysis of embedded software.[15] Haskell, though initially intended
as a research language,[17] has also been applied in areas such as aerospace systems, hardware
design and web programming.[16][17]
Other functional programming languages that have seen use in industry include Scala,[119] F#,[18][19]
Wolfram Language,[7] Lisp,[120] Standard ML[121][122] and Clojure.[123] Scala has been widely used in
Data science,[124] while ClojureScript,[125] Elm[126] or PureScript[127] are some of the functional
frontend programming languages used in production. Elixir's Phoenix framework is also used by
some relatively popular commercial projects, such as Font Awesome or Allegro (one of the biggest
e-commerce platforms in Poland)[128]'s classified ads platform Allegro Lokalnie.[129]

Functional "platforms" have been popular in finance for risk analytics (particularly with large
investment banks). Risk factors are coded as functions that form interdependent graphs
(categories) to measure correlations in market shifts, similar in manner to Gröbner basis
optimizations but also for regulatory frameworks such as Comprehensive Capital Analysis and
Review. Given the use of OCaml and Caml variations in finance, these systems are sometimes
considered related to a categorical abstract machine. Functional programming is heavily influenced
by category theory.

Education

Many universities teach functional programming.[130][131][132][133] Some treat it as an introductory

programming concept[133] while others first teach imperative programming methods.[132][134]

Fuera de la informática, la programación funcional se utiliza para enseñar resolución de problemas,

conceptos algebraicos y geométricos. [ 135 ] 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 enseñar programación durante
años. [ 136 ] [ 137 ]

Véase también

Evaluación entusiasta Portal de programación

informática
Programación reactiva funcional

Programación funcional inductiva

Lista de lenguajes de programación funcional

Lista de temas de programación funcional

Función anidada
 Programación puramente funcional

Notas y referencias

1. Hudak, Paul (septiembre de 1989). "Concepción, evolución y aplicación de lenguajes de

programación funcional" (https://web.archive.org/web/20160131083528/http://www.dbnet.ec
e.ntua.gr/~adamo/languages/books/p359-hudak.pdf) (PDF) . ACM Computing Surveys . 21
(3): 359–411. doi : 10.1145/72551.72554 (https://doi.org/10.1145%2F72551.72554) . S2CID
207637854 (https://api.semanticscholar.org/CorpusID:207637854) . Archivado desde el
original (http://www.dbnet.ece.ntua.gr/~adamo/languages/books/p359-hudak.pdf) (PDF) el
2016-01-31 . Consultado el 2013-08-10 . (https://web.archive.org/web/20160131083528/htt
p://www.dbnet.ece.ntua.gr/~adamo/languages/books/p359-hudak.pdf) (https://doi.org/10.1
145%2F72551.72554) (https://api.semanticscholar.org/CorpusID:207637854) (http://ww
w.dbnet.ece.ntua.gr/~adamo/languages/books/p359-hudak.pdf)

2. Hughes, John(1984)."Por qué es importante la programación funcional" (http://www.cse.chalm

ers.se/~rjmh/Papers/whyfp.html) . (http://www.cse.chalmers.se/~rjmh/Papers/whyfp.htm
l)

3. Clinger, Will (1987)."MultiTasking and MacScheme" (Multitarea y MacScheme) (http://www.ma

ctech.com/articles/mactech/Vol.03/03.12/Multitasking/index.html) .MacTech.3(12).
Consultado el 28 de agosto de 2008 . (http://www.mactech.com/articles/mactech/Vol.03/03.1
2/Multitasking/index.html)

4. Hartheimer, Anne (1987)."Programación de un editor de texto en MacScheme+Toolsmith" (http

s://web.archive.org/web/20110629183752/http://www.mactech.com/articles/mactech/Vol.0
3/03.1/SchemeWindows/index.html) .MacTech.3(1). Archivado desdeel original (http://www.
mactech.com/articles/mactech/Vol.03/03.1/SchemeWindows/index.html) el 29 de junio de
2011.Consultado el 28 de agosto de 2008 . (https://web.archive.org/web/20110629183752/htt
p://www.mactech.com/articles/mactech/Vol.03/03.1/SchemeWindows/index.html) (http://w
ww.mactech.com/articles/mactech/Vol.03/03.1/SchemeWindows/index.html)

5. Kidd, Eric. Terrorism Response Training in Scheme (https://web.archive.org/web/201012211109

47/http://cufp.galois.com/2007/abstracts.html#EricKidd) . CUFP 2007. Archivado desdeel
original (http://cufp.galois.com/2007/abstracts.html#EricKidd) el 21 de diciembre de
2010.Consultado el 26 de agosto de 2009 . (https://web.archive.org/web/20101221110947/htt
p://cufp.galois.com/2007/abstracts.html#EricKidd) (http://cufp.galois.com/2007/abstracts.
html#EricKidd)
 6. Cleis, Richard. Scheme in Space (https://web.archive.org/web/20100527100429/http://cufp.ga
lois.com/2006/abstracts.html#RichardCleis) . CUFP 2006. Archivado desdeel original (http://
cufp.galois.com/2006/abstracts.html#RichardCleis) el 27 de mayo de 2010.Consultado
el 26 de agosto de 2009 . (https://web.archive.org/web/20100527100429/http://cufp.galois.co
m/2006/abstracts.html#RichardCleis) (http://cufp.galois.com/2006/abstracts.html#Richard
Cleis)

7. "Guía del lenguaje Wolfram: programación funcional" (http://reference.wolfram.com/language/

guide/FunctionalProgramming.html) . 2015. Consultado el 24 de agosto de 2015 . (http://refe
rence.wolfram.com/language/guide/FunctionalProgramming.html)

8. "Lenguaje de programación funcional vs. procedimental" (https://web.archive.org/web/200711

13175801/http://amath.colorado.edu/computing/mmm/funcproc.html) . Departamento de
Matemática Aplicada . Universidad de Colorado. Archivado desde el original (http://amath.color
ado.edu/computing/mmm/funcproc.html) el 13 de noviembre de 2007 . Consultado
el 28 de agosto de 2006 . (https://web.archive.org/web/20071113175801/http://amath.colora
do.edu/computing/mmm/funcproc.html) (http://amath.colorado.edu/computing/mmm/func
proc.html)

9. "State-Based Scripting in Uncharted 2" (https://web.archive.org/web/20121215014637/http://

www.gameenginebook.com/gdc09-statescripting-uncharted2.pdf) (PDF). Archived from the
original (http://www.gameenginebook.com/gdc09-statescripting-uncharted2.pdf) (PDF) on
2012-12-15. Retrieved 2011-08-08.

10. "Who uses Erlang for product development?" (http://erlang.org/faq/introduction.html#idp3258

2608) . Frequently asked questions about Erlang. Retrieved 2018-04-27.

11. Armstrong, Joe (June 2007). "A history of Erlang". Proceedings of the third ACM SIGPLAN
conference on History of programming languages. Third ACM SIGPLAN Conference on History
of Programming Languages. San Diego, California. doi:10.1145/1238844.1238850 (https://doi.
org/10.1145%2F1238844.1238850) . ISBN 9781595937667.

12. Larson, Jim (March 2009). "Erlang for concurrent programming" (https://doi.org/10.1145%2F1
467247.1467263) . Communications of the ACM. 52 (3): 48. doi:10.1145/1467247.1467263 (h
ttps://doi.org/10.1145%2F1467247.1467263) . S2CID 524392 (https://api.semanticscholar.or
g/CorpusID:524392) .

13. "The Elixir Programming Language" (https://elixir-lang.org/) . Retrieved 2021-02-14.

14. Minsky, Yaron; Weeks, Stephen (July 2008). "Caml Trading — experiences with functional
programming on Wall Street". Journal of Functional Programming. 18 (4): 553–564.
doi:10.1017/S095679680800676X (https://doi.org/10.1017%2FS095679680800676X)
(inactive 1 November 2024). S2CID 30955392 (https://api.semanticscholar.org/CorpusID:3095
5392) .

15. Leroy, Xavier. Some uses of Caml in Industry (https://web.archive.org/web/20111008170929/ht

tp://cufp.galois.com/2007/slides/XavierLeroy.pdf) (PDF). CUFP 2007. Archived from the
original (http://cufp.galois.com/2007/slides/XavierLeroy.pdf) (PDF) on 2011-10-08. Retrieved
2009-08-26.

16. "Haskell in industry" (http://www.haskell.org/haskellwiki/Haskell_in_industry) . Haskell Wiki.

Retrieved 2009-08-26. "Haskell has a diverse range of use commercially, from aerospace and
defense, to finance, to web startups, hardware design firms and lawnmower manufacturers."

17. Hudak, Paul; Hughes, J.; Jones, S. P.; Wadler, P. (June 2007). A history of Haskell: being lazy with
class (http://dl.acm.org/citation.cfm?doid=1238844.1238856) . Third ACM SIGPLAN
Conference on History of Programming Languages. San Diego, California.
doi:10.1145/1238844.1238856 (https://doi.org/10.1145%2F1238844.1238856) . Retrieved
2013-09-26.

18. Mansell, Howard (2008). Quantitative Finance in F# (https://web.archive.org/web/20150708125

937/http://cufp.galois.com/2008/abstracts.html#MansellHoward) . CUFP 2008. Archived
from the original (http://cufp.galois.com/2008/abstracts.html#MansellHoward) on 2015-07-
08. Retrieved 2009-08-29.

19. Peake, Alex (2009). The First Substantial Line of Business Application in F# (https://web.archive.
org/web/20091017070140/http://cufp.galois.com/2009/abstracts.html#AlexPeakeAdamGrani
cz) . CUFP 2009. Archived from the original (http://cufp.galois.com/2009/abstracts.html#Ale
xPeakeAdamGranicz) on 2009-10-17. Retrieved 2009-08-29.

20. de Moura, Leonardo; Ullrich, Sebastian (July 2021). "The Lean 4 Theorem Prover and
Programming Language". Lecture Notes in Artificial Intelligence. Conference on Automated
Deduction. Vol. 12699. pp. 625–635. doi:10.1007/978-3-030-79876-5_37 (https://doi.org/10.10
07%2F978-3-030-79876-5_37) . ISSN 1611-3349 (https://search.worldcat.org/issn/1611-334
9) .

21. Banz, Matt (2017-06-27). "An introduction to functional programming in JavaScript" (https://op
ensource.com/article/17/6/functional-javascript) . Opensource.com. Retrieved 2021-01-09.

22. "The useR! 2006 conference schedule includes papers on the commercial use of R" (http://ww
w.r-project.org/useR-2006/program.html) . R-project.org. 2006-06-08. Retrieved 2011-06-20.
23. Chambers, John M. (1998). Programming with Data: A Guide to the S Language. Springer Verlag.
pp. 67–70. ISBN 978-0-387-98503-9.

24. Novatchev, Dimitre. "The Functional Programming Language XSLT — A proof through
examples" (http://fxsl.sourceforge.net/articles/FuncProg/Functional%20Programming.html) .
Retrieved May 27, 2006.

25. Mertz, David. "XML Programming Paradigms (part four): Functional Programming approached
to XML processing" (http://gnosis.cx/publish/programming/xml_models_fp.html) . IBM
developerWorks. Retrieved May 27, 2006.

26. Chamberlin, Donald D.; Boyce, Raymond F. (1974). "SEQUEL: A structured English query
language". Proceedings of the 1974 ACM SIGFIDET: 249–264.

27. Functional Programming with C# - Simon Painter - NDC Oslo 2020 (https://ghostarchive.org/varc
hive/youtube/20211030/gvyTB4aMI4o) , 8 August 2021, archived from the original (https://w
ww.youtube.com/watch?v=gvyTB4aMI4o) on 2021-10-30, retrieved 2021-10-23

28. "Functional programming - Kotlin Programming Language" (https://kotlinlang.org/docs/tutorial

s/kotlin-for-py/functional-programming.html) . Kotlin. Retrieved 2019-05-01.

29. Dominus, Mark J. (2005). Higher-Order Perl. Morgan Kaufmann. ISBN 978-1-55860-701-9.

30. Holywell, Simon (2014). Functional Programming in PHP. php[architect]. ISBN 9781940111056.

31. The Cain Gang Ltd. "Python Metaclasses: Who? Why? When?" (https://web.archive.org/web/20
090530030205/http://www.python.org/community/pycon/dc2004/papers/24/metaclasses-py
con.pdf) (PDF). Archived from the original (https://www.python.org/community/pycon/dc200
4/papers/24/metaclasses-pycon.pdf) (PDF) on 30 May 2009. Retrieved 27 June 2009.

32. "GopherCon 2020: Dylan Meeus - Functional Programming with Go" (https://www.youtube.co
m/watch?v=wqs8n5Uk5OM) . YouTube. 22 December 2020.

33. "Functional Language Features: Iterators and Closures - The Rust Programming Language" (htt
ps://doc.rust-lang.org/book/ch13-00-functional-features.html) . doc.rust-lang.org. Retrieved
2021-01-09.

34. Vanderbauwhede, Wim (18 July 2020). "Cleaner code with functional programming" (https://we
b.archive.org/web/20200728013926/https://wimvanderbauwhede.github.io/articles/declutteri
ng-with-functional-programming/) . Archived from the original (https://wimvanderbauwhede.g
ithub.io/articles/decluttering-with-functional-programming/) on 28 July 2020. Retrieved
6 October 2020.
35. "Effective Scala" (https://web.archive.org/web/20120619075044/http://twitter.github.com/effe
ctivescala/?sd) . Scala Wiki. Archived from the original (https://twitter.github.com/effectivesc
ala/?sd) on 2012-06-19. Retrieved 2012-02-21. "Effective Scala."

36. "Documentation for package java.util.function since Java 8 (also known as Java 1.8)" (https://
docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html) . Retrieved
2021-06-16.

37. Turing, A. M. (1937). "Computability and λ-definability". The Journal of Symbolic Logic. 2 (4).
Cambridge University Press: 153–163. doi:10.2307/2268280 (https://doi.org/10.2307%2F2268
280) . JSTOR 2268280 (https://www.jstor.org/stable/2268280) . S2CID 2317046 (https://api.
semanticscholar.org/CorpusID:2317046) .

38. Haskell Brooks Curry; Robert Feys (1958). Combinatory Logic (https://archive.org/details/comb
inatorylogic0002curr) . North-Holland Publishing Company. Retrieved 10 February 2013.

39. Church, A. (1940). "A Formulation of the Simple Theory of Types". Journal of Symbolic Logic. 5
(2): 56–68. doi:10.2307/2266170 (https://doi.org/10.2307%2F2266170) . JSTOR 2266170 (ht
tps://www.jstor.org/stable/2266170) . S2CID 15889861 (https://api.semanticscholar.org/Cor
pusID:15889861) .

40. McCarthy, John (June 1978). History of Lisp (http://jmc.stanford.edu/articles/lisp/lisp.pdf)

(PDF). History of Programming Languages. Los Angeles, CA. pp. 173–185.
doi:10.1145/800025.808387 (https://doi.org/10.1145%2F800025.808387) .

41. John McCarthy (1960). "Recursive functions of symbolic expressions and their computation by
machine, Part I." (http://jmc.stanford.edu/articles/recursive/recursive.pdf) (PDF).
Communications of the ACM. 3 (4). ACM New York, NY, US: 184–195.
doi:10.1145/367177.367199 (https://doi.org/10.1145%2F367177.367199) . S2CID 1489409
(https://api.semanticscholar.org/CorpusID:1489409) .

42. Guy L. Steele; Richard P. Gabriel (February 1996). "The evolution of Lisp". History of
programming languages---II (http://dreamsongs.com/Files/HOPL2-Uncut.pdf) (PDF).
pp. 233–330. doi:10.1145/234286.1057818 (https://doi.org/10.1145%2F234286.1057818) .
ISBN 978-0-201-89502-5. S2CID 47047140 (https://api.semanticscholar.org/CorpusID:470471
40) .

43. The memoir of Herbert A. Simon (1991), Models of My Life pp.189-190 ISBN 0-465-04640-1
claims that he, Al Newell, and Cliff Shaw are "...commonly adjudged to be the parents of [the]
artificial intelligence [field]," for writing Logic Theorist, a program that proved theorems from
Principia Mathematica automatically. To accomplish this, they had to invent a language and a
paradigm that, viewed retrospectively, embeds functional programming.
44. Landin, Peter J. (1964). "The mechanical evaluation of expressions" (https://doi.org/10.1093%
2Fcomjnl%2F6.4.308) . The Computer Journal. 6 (4). British Computer Society: 308–320.
doi:10.1093/comjnl/6.4.308 (https://doi.org/10.1093%2Fcomjnl%2F6.4.308) .

45. Diehl, Stephan; Hartel, Pieter; Sestoft, Peter (2000). "Abstract machines for programming
language implementation". Future Generation Computer Systems. Vol. 16. pp. 739–751.

46. Landin, Peter J. (February 1965a). "Correspondence between ALGOL 60 and Church's Lambda-
notation: part I" (https://doi.org/10.1145%2F363744.363749) . Communications of the ACM. 8
(2). Association for Computing Machinery: 89–101. doi:10.1145/363744.363749 (https://doi.o
rg/10.1145%2F363744.363749) . S2CID 6505810 (https://api.semanticscholar.org/CorpusID:
6505810) .

47. Landin, Peter J. (March 1965b). "A correspondence between ALGOL 60 and Church's Lambda-
notation: part II" (https://doi.org/10.1145%2F363791.363804) . Communications of the ACM.
8 (3). Association for Computing Machinery: 158–165. doi:10.1145/363791.363804 (https://do
i.org/10.1145%2F363791.363804) . S2CID 15781851 (https://api.semanticscholar.org/Corpu
sID:15781851) .

48. Landin, Peter J. (March 1966b). "The next 700 programming languages" (https://doi.org/10.11
45%2F365230.365257) . Communications of the ACM. 9 (3). Association for Computing
Machinery: 157–166. doi:10.1145/365230.365257 (https://doi.org/10.1145%2F365230.36525
7) . S2CID 13409665 (https://api.semanticscholar.org/CorpusID:13409665) .

49. Backus, J. (1978). "Can programming be liberated from the von Neumann style?: A functional
style and its algebra of programs" (https://doi.org/10.1145%2F359576.359579) .
Communications of the ACM. 21 (8): 613–641. doi:10.1145/359576.359579 (https://doi.org/1
0.1145%2F359576.359579) .

50. R.M. Burstall. Design considerations for a functional programming language. Invited paper,
Proc. Infotech State of the Art Conf. "The Software Revolution", Copenhagen, 45–57 (1977)

51. R.M. Burstall and J. Darlington. A transformation system for developing recursive programs.
Journal of the Association for Computing Machinery 24(1):44–67 (1977)

52. R.M. Burstall, D.B. MacQueen and D.T. Sannella. HOPE: an experimental applicative language.
Proceedings 1980 LISP Conference, Stanford, 136–143 (1980).

53. "Make discovering assign() easier!" (https://web.archive.org/web/20230419060430/https://for

um.openscad.org/Make-discovering-assign-easier-td10964.html) . OpenSCAD. Archived from
the original (https://forum.openscad.org/Make-discovering-assign-easier-td10964.html) on
2023-04-19.
54. Peter Bright (March 13, 2018). "Developers love trendy new languages but earn more with
functional programming" (https://arstechnica.com/gadgets/2018/03/developers-love-trendy-n
ew-languages-but-earn-more-with-functional-programming/) . Ars Technica.

55. John Leonard (January 24, 2017). "The stealthy rise of functional programming" (https://www.c
omputing.co.uk/ctg/analysis/3003123/the-slow-but-steady-rise-of-functional-programming) .
Computing.

56. Leo Cheung (May 9, 2017). "Is functional programming better for your startup?" (https://www.in
foworld.com/article/3190185/software/is-functional-programming-better-for-your-startup.htm
l) . InfoWorld.

57. Sean Tull - Monoidal Categories for Formal Concept Analysis.

58. Pountain, Dick. "Functional Programming Comes of Age" (https://web.archive.org/web/200608

27094123/http://byte.com/art/9408/sec11/art1.htm) . Byte (August 1994). Archived from the
original (http://byte.com/art/9408/sec11/art1.htm) on 2006-08-27. Retrieved August 31,
2006.

59. "ISO/IEC JTC 1/SC 22/WG5/N2137 – Fortran 2015 Committee Draft (J3/17-007r2)" (https://wg
5-fortran.org/N2101-N2150/N2137.pdf) (PDF). International Organization for
Standardization. July 6, 2017. pp. 336–338.

60. "Revised^6 Report on the Algorithmic Language Scheme" (http://www.r6rs.org/final/html/r6rs/

r6rs-Z-H-8.html#node_sec_5.11) . R6rs.org. Retrieved 2013-03-21.

61. "Revised^6 Report on the Algorithmic Language Scheme - Rationale" (http://www.r6rs.org/fina

l/html/r6rs-rationale/r6rs-rationale-Z-H-7.html#node_sec_5.3) . R6rs.org. Retrieved
2013-03-21.

62. Clinger, William (1998). "Proper tail recursion and space efficiency". Proceedings of the ACM
SIGPLAN 1998 conference on Programming language design and implementation - PLDI '98.
pp. 174–185. doi:10.1145/277650.277719 (https://doi.org/10.1145%2F277650.277719) .
ISBN 0897919874. S2CID 16812984 (https://api.semanticscholar.org/CorpusID:16812984) .

63. Baker, Henry (1994). "CONS Should Not CONS Its Arguments, Part II: Cheney on the M.T.A." (htt
ps://web.archive.org/web/20060303155622/http://home.pipeline.com/~hbaker1/CheneyMTA.
html) Archived from the original (http://home.pipeline.com/~hbaker1/CheneyMTA.html) on
2006-03-03. Retrieved 2020-04-29.

64. Turner, D.A. (2004-07-28). "Total Functional Programming" (http://www.jucs.org/jucs_10_7/tota

l_functional_programming) . Journal of Universal Computer Science. 10 (7): 751–768.
doi:10.3217/jucs-010-07-0751 (https://doi.org/10.3217%2Fjucs-010-07-0751) .
65. The Implementation of Functional Programming Languages (http://research.microsoft.com/~s
imonpj/papers/slpj-book-1987/index.htm) . Simon Peyton Jones, published by Prentice Hall,
1987

66. Launchbury, John (March 1993). A Natural Semantics for Lazy Evaluation. Symposium on
Principles of Programming Languages. Charleston, South Carolina: ACM. pp. 144–154.
doi:10.1145/158511.158618 (https://doi.org/10.1145%2F158511.158618) .

67. Robert W. Harper (2009). Practical Foundations for Programming Languages (https://web.archiv
e.org/web/20160407095249/https://www.cs.cmu.edu/~rwh/plbook/book.pdf) (PDF).
Archived from the original (https://www.cs.cmu.edu/~rwh/plbook/book.pdf) (PDF) on 2016-
04-07.

68. Huet, Gérard P. (1973). "The Undecidability of Unification in Third Order Logic". Information and
Control. 22 (3): 257–267. doi:10.1016/s0019-9958(73)90301-x (https://doi.org/10.1016%2Fs0
019-9958%2873%2990301-x) .

69. Huet, Gérard (Sep 1976). Resolution d'Equations dans des Langages d'Ordre 1,2,...ω (Ph.D.) (in
French). Universite de Paris VII.

70. Huet, Gérard (2002). "Higher Order Unification 30 years later" (http://pauillac.inria.fr/~huet/PUB
LIC/Hampton.pdf) (PDF). In Carreño, V.; Muñoz, C.; Tahar, S. (eds.). Proceedings, 15th
International Conference TPHOL. LNCS. Vol. 2410. Springer. pp. 3–12.

71. Wells, J. B. (1993). "Typability and type checking in the second-order lambda-calculus are
equivalent and undecidable". Tech. Rep. 93-011: 176–185. CiteSeerX 10.1.1.31.3590 (https://cit
eseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.31.3590) .

72. Leroy, Xavier (17 September 2018). "The Compcert verified compiler" (http://compcert.inria.fr/d
oc/index.html) .

73. Peyton Jones, Simon; Vytiniotis, Dimitrios; Weirich, Stephanie; Geoffrey Washburn (April 2006).
"Simple unification-based type inference for GADTs" (http://research.microsoft.com/en-us/um/
people/simonpj/papers/gadt/) . Icfp 2006: 50–61.

74. "OCaml Manual" (https://caml.inria.fr/pub/docs/manual-ocaml/gadts.html) . caml.inria.fr.

Retrieved 2021-03-08.

75. "Algebraic Data Types" (https://docs.scala-lang.org/scala3/book/types-adts-gadts.html) .

Scala Documentation. Retrieved 2021-03-08.
76. Kennedy, Andrew; Russo, Claudio V. (October 2005). Generalized Algebraic Data Types and
Object-Oriented Programming (https://web.archive.org/web/20061229164852/http://research.
microsoft.com/~akenn/generics/gadtoop.pdf) (PDF). OOPSLA. San Diego, California: ACM.
doi:10.1145/1094811.1094814 (https://doi.org/10.1145%2F1094811.1094814) .
ISBN 9781595930316. Archived from the original (https://www.microsoft.com/en-us/research/
publication/generalized-algebraic-data-types-and-object-oriented-programming/) on 2006-12-
29.

77. Hughes, John. "Why Functional Programming Matters" (http://www.cse.chalmers.se/~rjmh/Pa

pers/whyfp.pdf) (PDF). Chalmers University of Technology.

78. Purely functional data structures (http://www.cambridge.org/us/academic/subjects/computer-

science/algorithmics-complexity-computer-algebra-and-computational-g/purely-functional-dat
a-structures) by Chris Okasaki, Cambridge University Press, 1998, ISBN 0-521-66350-4

79. L’orange, Jean Niklas. "polymatheia - Understanding Clojure's Persistent Vector, pt. 1" (http://w
ww.hypirion.com/musings/understanding-persistent-vector-pt-1) . Polymatheia. Retrieved
2018-11-13.

80. Michael Barr, Charles Well - Category theory for computer science.

81. Newbern, J. "All About Monads: A comprehensive guide to the theory and practice of monadic
programming in Haskell" (http://monads.haskell.cz/html/index.html/html/) . Retrieved
2008-02-14.

82. "Thirteen ways of looking at a turtle" (https://fsharpforfunandprofit.com/posts/13-ways-of-look

ing-at-a-turtle/#2-basic-fp---a-module-of-functions-with-immutable-state) . fF# for fun and
profit. Retrieved 2018-11-13.

83. Paulson, Larry C. (28 June 1996). ML for the Working Programmer (https://books.google.com/b
ooks?id=XppZdaDs7e0C) . Cambridge University Press. ISBN 978-0-521-56543-1. Retrieved
10 February 2013.

84. Spiewak, Daniel (26 August 2008). "Implementing Persistent Vectors in Scala" (https://web.arc
hive.org/web/20150923205254/http://www.codecommit.com/blog/scala/implementing-persi
stent-vectors-in-scala) . Code Commit. Archived from the original (http://www.codecommit.co
m/blog/scala/implementing-persistent-vectors-in-scala) on 23 September 2015. Retrieved
17 April 2012.
85. "Which programs are fastest? | Computer Language Benchmarks Game" (https://web.archive.o
rg/web/20130520162513/http://benchmarksgame.alioth.debian.org/u32/which-programs-are-
fastest.php?gcc=on&ghc=on&clean=on&ocaml=on&sbcl=on&fsharp=on&racket=on&clojure=o
n&hipe=on&calc=chart) . benchmarksgame.alioth.debian.org. Archived from the original (htt
p://benchmarksgame.alioth.debian.org/u32/which-programs-are-fastest.php?gcc=on&ghc=on
&clean=on&ocaml=on&sbcl=on&fsharp=on&racket=on&clojure=on&hipe=on&calc=chart) on
2013-05-20. Retrieved 2011-06-20.

86. Igor Pechtchanski; Vivek Sarkar (2005). "Immutability specification and its applications".
Concurrency and Computation: Practice and Experience. 17 (5–6): 639–662.
doi:10.1002/cpe.853 (https://doi.org/10.1002%2Fcpe.853) . S2CID 34527406 (https://api.se
manticscholar.org/CorpusID:34527406) .

87. "An In-Depth Look at Clojure Collections" (https://www.infoq.com/articles/in-depth-look-clojure

-collections/) . InfoQ. Retrieved 2024-04-29.

88. "References and Borrowing - The Rust Programming Language" (https://doc.rust-lang.org/boo

k/ch04-02-references-and-borrowing.html) . doc.rust-lang.org. Retrieved 2024-04-29.

89. "Validating References with Lifetimes - The Rust Programming Language" (https://doc.rust-lan
g.org/book/ch10-03-lifetime-syntax.html) . doc.rust-lang.org. Retrieved 2024-04-29.

90. "Concurrent Collections (The Java™ Tutorials > Essential Java Classes > Concurrency)" (http
s://docs.oracle.com/javase/tutorial/essential/concurrency/collections.html) .
docs.oracle.com. Retrieved 2024-04-29.

91. "Understanding The Actor Model To Build Non-blocking, High-throughput Distributed Systems -
Scaleyourapp" (https://scaleyourapp.com/actor-model/) . scaleyourapp.com. 2023-01-28.
Retrieved 2024-04-29.

92. Cesarini, Francesco; Thompson, Simon (2009). Erlang programming: a concurrent approach to
software development (1st ed.). O'Reilly Media, Inc. (published 2009-06-11). p. 6. ISBN 978-0-
596-55585-6.

93. "Chapter 25. Profiling and optimization" (http://book.realworldhaskell.org/read/profiling-and-op

timization.html#x_eK1) . Book.realworldhaskell.org. Retrieved 2011-06-20.

94. Berthe, Samuel (2024-04-29), samber/lo (https://github.com/samber/lo) , retrieved

2024-04-29

95. "Go Wiki: Compiler And Runtime Optimizations - The Go Programming Language" (https://go.d
ev/wiki/CompilerOptimizations) . go.dev. Retrieved 2024-04-29.
 96. "Comparing Performance: Loops vs. Iterators - The Rust Programming Language" (https://doc.r
ust-lang.org/book/ch13-04-performance.html) . doc.rust-lang.org. Retrieved 2024-04-29.

97. Hartel, Pieter; Henk Muller; Hugh Glaser (March 2004). "The Functional C experience" (https://w
eb.archive.org/web/20110719201553/http://www.ub.utwente.nl/webdocs/ctit/1/00000084.pd
f) (PDF). Journal of Functional Programming. 14 (2): 129–135.
doi:10.1017/S0956796803004817 (https://doi.org/10.1017%2FS0956796803004817) .
S2CID 32346900 (https://api.semanticscholar.org/CorpusID:32346900) . Archived from the
original (http://www.ub.utwente.nl/webdocs/ctit/1/00000084.pdf) (PDF) on 2011-07-19.
Retrieved 2006-05-28.; David Mertz. "Functional programming in Python, Part 3" (https://web.ar
chive.org/web/20071016124848/http://www-128.ibm.com/developerworks/linux/library/l-pro
g3.html) . IBM developerWorks. Archived from the original (http://www-128.ibm.com/develope
rworks/linux/library/l-prog3.html) on 2007-10-16. Retrieved 2006-09-17.(Part 1 (https://web.a
rchive.org/web/20071016124848/http://www-128.ibm.com/developerworks/linux/library/l-pro
g.html) , Part 2 (https://web.archive.org/web/20071016124848/http://www-128.ibm.com/dev
eloperworks/linux/library/l-prog2.html) )

98. "Functions — D Programming Language 2.0" (http://www.digitalmars.com/d/2.0/function.html

#pure-functions) . Digital Mars. 30 December 2012.

99. "Lua Unofficial FAQ (uFAQ)" (http://www.luafaq.org/#T1.2) .

100. "First-Class Functions in Go - The Go Programming Language" (https://golang.org/doc/codewa

lk/functions/) . golang.org. Retrieved 2021-01-04.

101. Eich, Brendan (3 April 2008). "Popularity" (https://brendaneich.com/2008/04/popularity/) .

102. van Rossum, Guido (2009-04-21). "Origins of Python's "Functional" Features" (http://python-hist
ory.blogspot.de/2009/04/origins-of-pythons-functional-features.html) . Retrieved 2012-09-27.

103. "functools — Higher order functions and operations on callable objects" (https://docs.python.or
g/dev/library/functools.html#functools.reduce) . Python Software Foundation. 2011-07-31.
Retrieved 2011-07-31.

104. Skarsaune, Martin (2008). The SICS Java Port Project Automatic Translation of a Large Object
Oriented System from Smalltalk to Java.

105. Gosling, James. "Closures" (https://web.archive.org/web/20130414180002/https://blogs.oracl

e.com/jag/entry/closures) . James Gosling: on the Java Road. Oracle. Archived from the
original (http://blogs.oracle.com/jag/entry/closures) on 2013-04-14. Retrieved 11 May 2013.

106. Williams, Michael (8 April 2013). "Java SE 8 Lambda Quick Start" (https://blogs.oracle.com/jav
atraining/entry/java_se_8_lambda_quick) .
107. Bloch, Joshua (2008). "Item 15: Minimize Mutability". Effective Java (https://archive.org/detail
s/effectivejava00bloc_0) (Second ed.). Addison-Wesley. ISBN 978-0321356680.

108. "Object.freeze() - JavaScript | MDN" (https://developer.mozilla.org/en-US/docs/Web/JavaScrip

t/Reference/Global_Objects/Object/freeze) . developer.mozilla.org. Retrieved 2021-01-04.
"The Object.freeze() method freezes an object. A frozen object can no longer be changed;
freezing an object prevents new properties from being added to it, existing properties from
being removed, prevents changing the enumerability, configurability, or writability of existing
properties, and prevents the values of existing properties from being changed. In addition,
freezing an object also prevents its prototype from being changed. freeze() returns the same
object that was passed in."

109. Daniel Friedman; William Byrd; Oleg Kiselyov; Jason Hemann (2018). The Reasoned Schemer,
Second Edition. The MIT Press.

110. A. Casas, D. Cabeza, M. V. Hermenegildo. A Syntactic Approach to Combining Functional

Notation, Lazy Evaluation and Higher-Order in LP Systems. The 8th International Symposium
on Functional and Logic Programming (FLOPS'06), pages 142-162, April 2006.

111. "How I do my Computing" (https://stallman.org/stallman-computing.html) . stallman.org.

Retrieved 2024-04-29.

112. "Helix" (https://helix-editor.com/news/release-24-03-highlights/) . helix-editor.com. Retrieved

2024-04-29.

113. Wakeling, David (2007). "Spreadsheet functional programming" (http://www.activemode.org/w

ebroot/Workers/ActiveTraining/Programming/Pro_SpreadsheetFunctionalProgramming.pdf)
(PDF). Journal of Functional Programming. 17 (1): 131–143. doi:10.1017/S0956796806006186
(https://doi.org/10.1017%2FS0956796806006186) . ISSN 0956-7968 (https://search.worldca
t.org/issn/0956-7968) . S2CID 29429059 (https://api.semanticscholar.org/CorpusID:2942905
9) .

114. Peyton Jones, Simon; Burnett, Margaret; Blackwell, Alan (March 2003). "Improving the world's
most popular functional language: user-defined functions in Excel" (https://web.archive.org/we
b/20051016011341/http://research.microsoft.com/~simonpj/Papers/excel/index.htm) .
Archived from the original (http://research.microsoft.com/~simonpj/Papers/excel/index.ht
m) on 2005-10-16.

115. Rodger, Richard (11 December 2017). The Tao of Microservices. Manning.
ISBN 9781638351733.
116. Piro, Christopher (2009). Functional Programming at Facebook (https://web.archive.org/web/20
091017070140/http://cufp.galois.com/2009/abstracts.html#ChristopherPiroEugeneLetuch
y) . CUFP 2009. Archived from the original (http://cufp.galois.com/2009/abstracts.html#Chris
topherPiroEugeneLetuchy) on 2009-10-17. Retrieved 2009-08-29.

117. "Sim-Diasca: a large-scale discrete event concurrent simulation engine in Erlang" (http://resear
ch.edf.com/research-and-the-scientific-community/software/sim-diasca-80704.html) .
November 2011.

118. 1 million is so 2011 (https://blog.whatsapp.com/index.php/2012/01/1-million-is-so-2011/)

Archived (https://web.archive.org/web/20140219234031/http://blog.whatsapp.com/index.ph
p/2012/01/1-million-is-so-2011/) 2014-02-19 at the Wayback Machine // WhatsApp blog,
2012-01-06: "the last important piece of our infrastracture is Erlang"

119. Momtahan, Lee (2009). Scala at EDF Trading: Implementing a Domain-Specific Language for
Derivative Pricing with Scala (https://web.archive.org/web/20091017070140/http://cufp.galois.
com/2009/abstracts.html#LeeMomtahan) . CUFP 2009. Archived from the original (http://cuf
p.galois.com/2009/abstracts.html#LeeMomtahan) on 2009-10-17. Retrieved 2009-08-29.

120. Graham, Paul (2003). "Beating the Averages" (http://www.paulgraham.com/avg.html) .

Retrieved 2009-08-29.

121. Sims, Steve (2006). Building a Startup with Standard ML (http://cufp.galois.com/2006/slides/St

eveSims.pdf) (PDF). CUFP 2006. Retrieved 2009-08-29.

122. Laurikari, Ville (2007). Functional Programming in Communications Security (https://web.archiv

e.org/web/20101221110947/http://cufp.galois.com/2007/abstracts.html#VilleLaurikari) .
CUFP 2007. Archived from the original (http://cufp.galois.com/2007/abstracts.html#VilleLauri
kari) on 2010-12-21. Retrieved 2009-08-29.

123. Lorimer, R. J. (19 January 2009). "Live Production Clojure Application Announced" (http://www.
infoq.com/news/2009/01/clojure_production) . InfoQ.

124. Bugnion, Pascal (2016). Scala for Data Science (1st ed.). Packt. ISBN 9781785281372.

125. "Why developers like ClojureScript" (https://stackshare.io/clojurescript) . StackShare.

Retrieved 2024-04-29.

126. Herrick, Justin (2024-04-29), jah2488/elm-companies (https://github.com/jah2488/elm-compa

nies) , retrieved 2024-04-29

127. "Por qué a los desarrolladores les gusta PureScript" (https://stackshare.io/purescript) .

StackShare . Consultado el 29 de abril de 2024 . (https://stackshare.io/purescript)
128. Equipo, Editorial (8 de enero de 2019). "ALLEGRO: todo lo que necesita saber sobre el mejor
mercado en línea polaco" (https://ecommercegermany.com/blog/allegro-all-you-need-to-know-
about-the-best-polish-online-marketplace) . Noticias de comercio electrónico de Alemania .
Consultado el 29 de abril de 2024 . (https://ecommercegermany.com/blog/allegro-all-you-need
-to-know-about-the-best-polish-online-marketplace)

129. "Sitios web que utilizan Phoenix Framework - Wappalyzer" (https://www.wappalyzer.com/techn

ologies/web-frameworks/phoenix-framework/) . www.wappalyzer.com . Consultado
el 29 de abril de 2024 . (https://www.wappalyzer.com/technologies/web-frameworks/phoenix-f
ramework/)

130. "Programación funcional: 2019-2020" (https://www.cs.ox.ac.uk/teaching/courses/2019-2020/f

p/) . Departamento de Ciencias de la Computación de la Universidad de Oxford . Consultado
el 28 de abril de 2020 . (https://www.cs.ox.ac.uk/teaching/courses/2019-2020/fp/)

131. "Programación I (Haskell)" (https://www.imperial.ac.uk/computing/current-students/courses/1

20_1/) . Departamento de Informática del Imperial College de Londres . Consultado
el 28 de abril de 2020 . (https://www.imperial.ac.uk/computing/current-students/courses/120_
1/)

132. "Computer Science BSc - Modules" (https://www.nottingham.ac.uk/ugstudy/course/Computer-

Science-BSc#yearsmodules) . Consultado el 28 de abril de 2020. (https://www.nottingham.a
c.uk/ugstudy/course/Computer-Science-BSc#yearsmodules)

133. Abelson, Hal;Sussman, Gerald Jay(1985)."Prefacio a la segunda edición" (https://mitpress.mit.

edu/sites/default/files/sicp/full-text/book/book-Z-H-6.html) . Estructura e interpretación de
programas informáticos (http://mitpress.mit.edu/sicp/) (2.ª ed.). MIT Press. (https://mitpres
s.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-6.html) (http://mitpress.mit.edu/si
cp/)

134. John DeNero (otoño de 2019). «Computer Science 61A, Berkeley» (https://cs61a.org/articles/a
bout.html) . Departamento de Ingeniería Eléctrica y Ciencias de la Computación, Berkeley .
Consultado el 14 de agosto de 2020 . (https://cs61a.org/articles/about.html)

135. Emmanuel Schanzer de Bootstrap (https://twit.tv/shows/triangulation/episodes/196/)

entrevistado en el programa de televisión Triangulation de lacadena TWiT.tv

136. "¿Por qué utilizar Scheme para la programación introductoria?" (https://home.adelphi.edu/sblo

ch/class/pbd/testimonials/) . home.adelphi.edu . Consultado el 29 de abril de 2024 . (https://
home.adelphi.edu/sbloch/class/pbd/testimonials/)
137. Personal, IMACS (3 de junio de 2011). "¿Qué es Scheme y por qué es beneficioso para los
estudiantes?" (https://www.imacs.org/learn-computer-programming-using-scheme/) .
IMACS: cómo formar mejores pensadores para la vida . Consultado el 29 de abril de 2024 . (http
s://www.imacs.org/learn-computer-programming-using-scheme/)

Lectura adicional

Abelson, Hal ; Sussman, Gerald Jay (1985). Estructura e interpretación de programas informáticos
(https://mitpress.mit.edu/9780262510363/structure-and-interpretation-of-computer-programs/)
. MIT Press.

Cousineau, Guy y Michel Mauny. El enfoque funcional de la programación . Cambridge, Reino

Unido: Cambridge University Press , 1998.

Curry, Haskell Brooks y Feys, Robert y Craig, William. Combinatory Logic . Volumen I. North-
Holland Publishing Company, Ámsterdam, 1958.

Curry, Haskell B. ; Hindley, J. Roger ; Seldin, Jonathan P. (1972). Combinatory Logic . Vol. II.
Ámsterdam: Holanda Septentrional. ISBN 978-0-7204-2208-5.

Dominus, Mark Jason. Perl de orden superior (http://hop.perl.plover.com/book/pdf/HigherOrderPer

l.pdf) . Morgan Kaufmann . 2005.

Felleisen, Matthias; Findler, Robert; Flatt, Matthew; Krishnamurthi, Shriram (2018). Cómo diseñar
programas (http://www.htdp.org) . MIT Press.

Graham, Paul. ANSI Common LISP . Englewood Cliffs, Nueva Jersey: Prentice Hall , 1996.

MacLennan, Bruce J. Programación funcional: práctica y teoría . Addison-Wesley, 1990.

Michaelson, Greg (10 de abril de 2013). Introducción a la programación funcional mediante el

cálculo lambda . Courier Corporation. ISBN 978-0-486-28029-5.

O'Sullivan, Brian; Stewart, Don; Goerzen, John (2008). Haskell en el mundo real (http://book.realwo
rldhaskell.org/read/) . O'Reilly.

Pratt, Terrence W. y Marvin Victor Zelkowitz . Lenguajes de programación: diseño e implementación

. 3.ª ed. Englewood Cliffs, Nueva Jersey: Prentice Hall , 1996.

Salus, Peter H. Lenguajes de programación funcional y lógica . Vol. 4 del Manual de lenguajes de
programación. Indianápolis, Indiana: Macmillan Technical Publishing , 1998.

Thompson, Simon. Haskell: El arte de la programación funcional . Harlow, Inglaterra: Addison-

Wesley Longman Limited , 1996.
Enlaces externos

Ford, Neal. «Pensamiento funcional» (http://nealford.com/functionalthinking.html) . Consultado

el 10 de noviembre de 2021 .

Akhmechet, Slava (19 de junio de 2006). «defmacro: programación funcional para el resto de
nosotros» (http://www.defmacro.org/ramblings/fp.html) . Consultado el 24 de febrero de 2013
.Una introducción

Programación funcional en Python (por David Mertz): parte 1 (http://gnosis.cx/publish/programmi

ng/charming_python_13.html) , parte 2 (http://gnosis.cx/publish/programming/charming_pytho
n_16.html) , parte 3 (http://gnosis.cx/publish/programming/charming_python_19.html)