Functional programming - Wikipedia https://en.wikipedia.

org/wiki/Functional_programming

Functional programming
In computer science, functional programming is a programming paradigm where programs are
constructed by applying and composing functions. It is a declarative programming paradigm in which
function definitions are trees of expressions that map values to other values, rather than a sequence of
imperative statements which update the running state of the program.

In functional programming, functions are treated as first-class citizens, meaning that they can be bound
to names (including local identifiers), passed as arguments, and returned from other functions, just as
any other data type can. is allows programs to be wrien in a declarative and composable style,
where small functions are combined in a modular manner.

Functional programming is sometimes treated as synonymous with purely functional programming, a

subset of functional programming which treats all functions as deterministic mathematical functions,
or pure functions. When a pure function is called with some given arguments, it will always return the
same result, and cannot be affected by any mutable state or other side effects. is is in contrast with
impure procedures, common in imperative programming, which can have side effects (such as
modifying the program's state or taking input from a user). Proponents of purely functional
programming claim that by restricting side effects, programs can have fewer bugs, be easier to debug
and test, and be more suited to formal verification.[1][2]

Functional programming has its roots in academia, evolving from the lambda calculus, a formal system
of computation based only on functions. Functional programming has historically been less popular
than imperative programming, but many functional languages are seeing use today in industry and
education, including 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] and F#.[18][19] Lean is a functional
programming language commonly used for verifying mathematical theorems.[20] Functional
programming is also key to some languages that have found success in specific domains, like JavaScript
in the Web,[21] R in statistics,[22][23] J, K and Q in financial analysis, and Xery/XSLT for XML.[24][25]
Domain-specific declarative languages like SQL and Lex/Yacc use some elements of functional
programming, such as not allowing mutable values.[26] In addition, many other programming
languages support programming in a functional style or have implemented features from functional
programming, such as C++11, C#,[27] Kotlin,[28] Perl,[29] PHP,[30] Python,[31] Go,[32] Rust,[33] Raku,[34]
Scala,[35] and Java (since Java 8).[36]

History
e lambda calculus, developed in the 1930s by Alonzo Church, is a formal system of computation built
from function application. In 1937 Alan Turing proved that the lambda calculus and Turing machines
are equivalent models of computation,[37] showing that the lambda calculus is Turing complete.
Lambda calculus forms the basis of all functional programming languages. An equivalent theoretical
formulation, combinatory logic, was developed by Moses Schönfinkel and Haskell Curry in the 1920s
and 1930s.[38]

Church later developed a weaker system, the simply-typed lambda calculus, which extended the
lambda calculus by assigning a data type to all terms.[39] is forms the basis for statically typed

1 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

functional programming.

e first high-level functional programming language, Lisp, was developed in the late 1950s for the IBM
700/7000 series of scientific computers by John McCarthy while at Massachuses Institute of
Technology (MIT).[40] Lisp functions were defined using Church's lambda notation, extended with a
label construct to allow recursive functions.[41] Lisp first introduced many paradigmatic features of
functional programming, though early Lisps were multi-paradigm languages, and incorporated support
for numerous programming styles as new paradigms evolved. Later dialects, such as Scheme and
Clojure, and offshoots such as Dylan and Julia, sought to simplify and rationalise Lisp around a cleanly
functional core, while Common Lisp was designed to preserve and update the paradigmatic features of
the numerous older dialects it replaced.[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.

e 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, Maceen
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),

2 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

which associated functional programs with constructive proofs expressed as dependent types. is led
to new approaches to interactive theorem proving and has influenced the development of subsequent
functional programming languages.

e 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]

Functional programming continues to be used in commercial seings.[54][55][56]

Concepts
A number of concepts[57] and paradigms are specific to functional programming, and generally foreign
to imperative programming (including object-oriented programming). However, programming
languages oen cater to several programming paradigms, so programmers using "mostly imperative"
languages may have utilized some of these concepts.[58]

First-class and higher-order functions

Higher-order functions are functions that can either take other functions as arguments or return them
as results. In calculus, an example of a higher-order function is the differential operator , which
returns the derivative of a function .

Higher-order functions are closely related to first-class functions in that higher-order functions and
first-class functions both allow functions as arguments and results of other functions. e distinction
between the two is subtle: "higher-order" describes a mathematical concept of functions that operate on
other functions, while "first-class" is a computer science term for programming language entities that
have no restriction on their use (thus first-class functions can appear anywhere in the program that
other first-class entities like numbers can, including as arguments to other functions and as their return
values).

Higher-order functions enable partial application or currying, a technique that applies a function to its
arguments one at a time, with each application returning a new function that accepts the next
argument. is lets a programmer succinctly express, for example, the successor function as the
addition operator partially applied to the natural number one.

Pure functions
Pure functions (or expressions) have no side effects (memory or I/O). is means that pure functions
have several useful properties, many of which can be used to optimize the code:

▪ If the result of a pure expression is not used, it can be removed without affecting other
expressions.
▪ If a pure function is called with arguments that cause no side-effects, the result is

3 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

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, leing 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. is
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.

e 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 paerns 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

4 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

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. e 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 aempt 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.

e 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. e use of algebraic datatypes 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.
ese 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.

5 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

rough 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 C
programming language that is wrien 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. is 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
Purely functional data structures are oen represented in a different way to their imperative
counterparts.[78] For example, the array with constant access and update times is a basic component of
most imperative languages, and many imperative data-structures, such as the hash table and binary
heap, are based on arrays. Arrays can be replaced by maps or random access lists, which admit purely
functional implementation, but have logarithmic access and update times. Purely functional data
structures have persistence, a property of keeping previous versions of the data structure unmodified.
In Clojure, persistent data structures are used as functional alternatives to their imperative
counterparts. Persistent vectors, for example, use trees for partial updating. Calling the insert method
will result in some but not all nodes being created.[79]

Comparison to imperative programming

Functional programming is very different from imperative programming. e most significant
differences stem from the fact that functional programming avoids side effects, which are used in
imperative programming to implement state and I/O. Pure functional programming completely
prevents side-effects and provides referential transparency.

Higher-order functions are rarely used in older imperative programming. A traditional imperative

6 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

program might use a loop to traverse and modify a list. A functional program, on the other hand, would
probably use a higher-order "map" function that takes a function and a list, generating and returning a
new list by applying the function to each list item.

Imperative vs. functional programming

e following two examples (wrien in JavaScript) achieve the same effect: they multiply all even
numbers in an array by 10 and add them all, storing the final sum in the variable "result".

Traditional Imperative Loop:

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
ere are tasks (for example, maintaining a bank account balance) that oen 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.

e pure functional programming language Haskell implements them using monads, derived from
category theory.[80] Monads offer a way to abstract certain types of computational paerns, 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. is 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. is kind of approach enables mutability while still promoting the use of pure functions as the
preferred way to express computations.

7 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

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] is 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 e 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 it's 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. is 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 oen 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] is 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

8 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

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 (hps://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 nanoseconds, 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 1200 times
faster. Part of that can be aributed to the type checking and exception handling involved in the
implementation of even?, so let's take for instance the lo library (hps://github.com/samber/lo) 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 aributed to various
compiler optimizations, such as inlining.[95]

One distinguishing feature of Rust are zero-cost abstractions. is means that using them imposes no
additional runtime overhead. is 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 and Go[100] had first class functions from their inception.[101] Python had
support for "lambda", "map", "reduce", and "filter" in 1994, as well as closures in Python 2.2,[102] though
Python 3 relegated "reduce" to the functools standard library module.[103] First-class functions have
been introduced into other mainstream languages such as PHP 5.3, Visual Basic 9, C# 3.0, C++11, and
Kotlin.[28]

In PHP, anonymous classes, closures and lambdas are fully supported. Libraries and language
extensions for immutable data structures are being developed to aid programming in the functional
style.

In Java, anonymous classes can sometimes be used to simulate closures;[104] however, anonymous
classes are not always proper replacements to closures because they have more limited capabilities.[105]

9 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

Java 8 supports lambda expressions as a replacement for some anonymous classes.[106]

In C#, anonymous classes are not necessary, because closures and lambdas are fully supported.
Libraries and language extensions for immutable data structures are being developed to aid
programming in the functional style in C#.

Many object-oriented design paerns are expressible in functional programming terms: for example,
the strategy paern simply dictates use of a higher-order function, and the visitor paern roughly
corresponds to a catamorphism, or fold.

Similarly, the idea of immutable data from functional programming is oen included in imperative
programming languages,[107] for example the tuple in Python, which is an immutable array, and
Object.freeze() in JavaScript.[108]

Comparison to logic programming

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 paern of arguments, relations can be queried with any paern of inputs and outputs. Consider
the following logic program:

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

e 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 wrien in the nested
form:

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

10 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

e same definition in relational notation needs to be wrien 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]

grandparent(X) := parent(parent(X)).
parent(X) := mother(X).
parent(X) := father(X).

mother(charles) := elizabeth.
father(charles) := phillip.
mother(harry) := diana.
father(harry) := charles.

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

Ciao transforms the function-like notation into relational form and executes the resulting logic
program using the standard Prolog execution strategy.

Applications

Text editors
Emacs, a highly extensible text editor family uses its own Lisp dialect for writing plugins. e original
author of the most popular Emacs implementation, GNU Emacs and Emacs Lisp, Richard Stallman
considers Lisp one of his favorite programming languages.[111]

Helix, since version 24.03 supports previewing AST as S-expressions, which are also the core feature of
the Lisp programming language family.[112]

Spreadsheets
Spreadsheets can be considered a form of pure, zeroth-order, strict-evaluation functional programming
system.[113] However, spreadsheets generally lack higher-order functions as well as code reuse, and in
some implementations, also lack recursion. Several extensions have been developed for spreadsheet
programs to enable higher-order and reusable functions, but so far remain primarily academic in
nature.[114]

Academia
Functional programming is an active area of research in the field of programming language theory.
ere 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.

11 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/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][115][116][117] 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
soware[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 soware.[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,[118] F#,[18][19]
Wolfram Language,[7] Lisp,[119] Standard ML[120][121] and Clojure.[122] Scala has been widely used in
Data science,[123] while ClojureScript,[124] Elm[125] or PureScript[126] 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)[127]'s classified ads platform Allegro Lokalnie.[128]

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 shis, 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.[129][130][131][132] Some treat it as an introductory
programming concept[132] while others first teach imperative programming methods.[131][133]

Outside of computer science, functional programming is used to teach problem-solving, algebraic and
geometric concepts.[134] It has also been used to teach classical mechanics, as in the book Structure and
Interpretation of Classical Mechanics.

In particular, Scheme has been a relatively popular choice for teaching programming for years.[135][136]

See also
Computer
programming portal

▪ List of functional programming languages

▪ Purely functional programming
▪ Comparison of programming paradigms
▪ Eager evaluation
▪ List of functional programming topics

12 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

▪ Nested function
▪ Inductive functional programming
▪ Functional reactive programming

Notes and references

1. Hudak, Paul (September 1989). "Conception, evolution, and application of functional
programming languages" (http://www.dbnet.ece.ntua.gr/~adamo/languages/books/p
359-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).
2. Hughes, John (1984). "Why Functional Programming Matters" (http://www.cse.chalmer
s.se/~rjmh/Papers/whyfp.html).
3. Clinger, Will (1987). "MultiTasking and MacScheme" (http://www.mactech.com/articles/
mactech/Vol.03/03.12/Multitasking/index.html). MacTech. 3 (12). Retrieved 2008-08-28.
4. Hartheimer, Anne (1987). "Programming a Text Editor in MacScheme+Toolsmith" (http
s://web.archive.org/web/20110629183752/http://www.mactech.com/articles/mactech/
Vol.03/03.1/SchemeWindows/index.html). MacTech. 3 (1). Archived from the original (htt
p://www.mactech.com/articles/mactech/Vol.03/03.1/SchemeWindows/index.html) on
2011-06-29. Retrieved 2008-08-28.
5. Kidd, Eric. Terrorism Response Training in Scheme (http://cufp.galois.com/2007/abstracts.
html#EricKidd). CUFP 2007. Retrieved 2009-08-26.
6. Cleis, Richard. Scheme in Space (http://cufp.galois.com/2006/abstracts.html#RichardClei
s). CUFP 2006. Retrieved 2009-08-26.
7. "Wolfram Language Guide: Functional Programming" (http://reference.wolfram.com/la
nguage/guide/FunctionalProgramming.html). 2015. Retrieved 2015-08-24.
8. "Functional vs. Procedural Programming Language" (https://web.archive.org/web/2007
1113175801/http://amath.colorado.edu/computing/mmm/funcproc.html). Department
of Applied Math. University of Colorado. Archived from the original (http://amath.colora
do.edu/computing/mmm/funcproc.html) on 2007-11-13.
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-un
charted2.pdf) (PDF) on 2012-12-15. Retrieved 2011-08-08.
10. "Who uses Erlang for product development?" (http://erlang.org/faq/introduction.html#
idp32582608). 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.114
5%2F1467247.1467263). Communications of the ACM. 52 (3): 48.
doi:10.1145/1467247.1467263 (https://doi.org/10.1145%2F1467247.1467263).
S2CID 524392 (https://api.semanticscholar.org/CorpusID:524392).
13. "The Elixir Programming Language" (https://elixir-lang.org/). Retrieved 2021-02-14.

13 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

14. Minsky, Yaron; Weeks, Stephen (July 2008). "Caml Trading — experiences with
functional programming on Wall Street" (https://doi.org/10.1017%2FS09567968080067
6X). Journal of Functional Programming. 18 (4): 553–564.
doi:10.1017/S095679680800676X (https://doi.org/10.1017%2FS095679680800676X).
S2CID 30955392 (https://api.semanticscholar.org/CorpusID:30955392).
15. Leroy, Xavier. Some uses of Caml in Industry (http://cufp.galois.com/2007/slides/XavierLe
roy.pdf) (PDF). CUFP 2007. 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# (http://cufp.galois.com/2008/abstrac
ts.html#MansellHoward). CUFP 2008. Retrieved 2009-08-29.
19. Peake, Alex (2009). The First Substantial Line of Business Application in F# (https://web.arc
hive.org/web/20091017070140/http://cufp.galois.com/2009/abstracts.html#AlexPeake
AdamGranicz). CUFP 2009. Archived from the original (http://cufp.galois.com/2009/abs
tracts.html#AlexPeakeAdamGranicz) on 2009-10-17. Retrieved 2009-08-29.
20. https://pp.ipd.kit.edu/uploads/publikationen/demoura21lean4.pdf
21. comments, 27 Jun 2017 Matt Banz Feed 603up 2. "An introduction to functional
programming in JavaScript" (https://opensource.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" (htt
p://www.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_f
p.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.or
g/varchive/youtube/20211030/gvyTB4aMI4o), archived from the original (https://www.
youtube.com/watch?v=gvyTB4aMI4o) on 2021-10-30, retrieved 2021-10-23
28. "Functional programming - Kotlin Programming Language" (https://kotlinlang.org/doc
s/tutorials/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.

14 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

31. The Cain Gang Ltd. "Python Metaclasses: Who? Why? When?" (https://web.archive.org/
web/20090530030205/http://www.python.org/community/pycon/dc2004/papers/24/m
etaclasses-pycon.pdf) (PDF). Archived from the original (https://www.python.org/comm
unity/pycon/dc2004/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.yout
ube.com/watch?v=wqs8n5Uk5OM). YouTube.
33. "Functional Language Features: Iterators and Closures - The Rust Programming
Language" (https://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" (ht
tps://web.archive.org/web/20200728013926/https://wimvanderbauwhede.github.io/ar
ticles/decluttering-with-functional-programming/). Archived from the original (https://
wimvanderbauwhede.github.io/articles/decluttering-with-functional-programming/)
on 28 July 2020. Retrieved 6 October 2020.
35. "Effective Scala" (https://twitter.github.com/effectivescala/?sd). Scala Wiki. Retrieved
2012-02-21. "Effective Scala."
36. "Documentation for package java.util.function since Java 8 (also known as Java 1.8)" (ht
tps://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.230
7%2F2268280). 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
/combinatorylogic0002curr). 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 (https://www.jstor.org/stable/2266170). S2CID 15889861 (https://api.se
manticscholar.org/CorpusID:15889861).
40. McCarthy, John (June 1978). History of Lisp (http://jmc.stanford.edu/articles/lisp/lisp.pd
f) (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.105781
8). ISBN 978-0-201-89502-5. S2CID 47047140 (https://api.semanticscholar.org/CorpusI
D:47047140).
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.

15 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

44. Landin, Peter J. (1964). "The mechanical evaluation of expressions" (https://doi.org/10.1

093%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.org/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://doi.org/10.1145%2F363791.363804).
S2CID 15781851 (https://api.semanticscholar.org/CorpusID:15781851).
48. Landin, Peter J. (March 1966b). "The next 700 programming languages" (https://doi.org
/10.1145%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.365257). S2CID 13409665 (https://api.semanticscholar.org/CorpusID:134096
65).
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.35957
9). Communications of the ACM. 21 (8): 613–641. doi:10.1145/359576.359579 (https://doi.
org/10.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. Proc. 1980 LISP Conference, Stanford, 136–143 (1980).
53. "Make discovering assign() easier!" (https://web.archive.org/web/20230419060430/htt
ps://forum.openscad.org/Make-discovering-assign-easier-td10964.html). OpenSCAD.
Archived from the original (https://forum.openscad.org/Make-discovering-assign-easie
r-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-l
ove-trendy-new-languages-but-earn-more-with-functional-programming/). Ars
Technica.
55. John Leonard (January 24, 2017). "The stealthy rise of functional programming" (http
s://www.computing.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?" (http
s://www.infoworld.com/article/3190185/software/is-functional-programming-better-fo
r-your-startup.html). InfoWorld.
57. Sean Tull - Monoidal Categories for Formal Concept Analysis.
58. Pountain, Dick. "Functional Programming Comes of Age" (https://web.archive.org/web/
20060827094123/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.

16 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

59. "ISO/IEC JTC 1/SC 22/WG5/N2137" (https://isotc.iso.org/livelink/livelink/19089292/N213

7.pdf.flv?func=sspndocuments.Fetch&nodeid=19089292&viewType=1). International
Organization for Standardization. July 6, 2017. {{cite journal}}: Cite journal
requires |journal= (help)
60. "Revised^6 Report on the Algorithmic Language Scheme" (http://www.r6rs.org/final/ht
ml/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/final/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/CorpusI
D:16812984).
63. Baker, Henry (1994). "CONS Should Not CONS Its Arguments, Part II: Cheney on the
M.T.A." (http://home.pipeline.com/~hbaker1/CheneyMTA.html)
64. Turner, D.A. (2004-07-28). "Total Functional Programming" (http://www.jucs.org/jucs_10
_7/total_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/~simonpj/papers/slpj-book-1987/index.htm). Simon Peyton Jones, published by
Prentice Hall, 1987
66. John Launchbury (1993). "A Natural Semantics for Lazy Evaluation": 144–154.
CiteSeerX 10.1.1.35.2016 (https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.3
5.2016). {{cite journal}}: Cite journal requires |journal= (help)
67. Robert W. Harper (2009). Practical Foundations for Programming Languages (https://web.
archive.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://d
oi.org/10.1016%2Fs0019-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/PUBLIC/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://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.31.3590).
72. Leroy, Xavier (17 September 2018). "The Compcert verified compiler" (http://compcert.i
nria.fr/doc/index.html).
73. Peyton Jones, Simon; Vytiniotis, Dimitrios; Weirich, Stephanie; Geoffrey Washburn
(April 2006). "Simple unification-based type inference for GADTs" (http://research.micro
soft.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.

17 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

76. Kennedy, Andrew; Russo, Claudio (October 2005). Generalized Algebraic Data Types and
Object-Oriented Programming (https://web.archive.org/web/20061229164852/http://res
earch.microsoft.com/~akenn/generics/gadtoop.pdf) (PDF). San Diego, California.
ISBN 9781595930316. Archived from the original (http://research.microsoft.com/~aken
n/generics/gadtoop.pdf) (PDF) on 2006-12-29. {{cite book}}: |work= ignored (help)
source of citation (http://lambda-the-ultimate.org/node/1134)
77. Hughes, John. "Why Functional Programming Matters" (http://www.cse.chalmers.se/~rj
mh/Papers/whyfp.pdf) (PDF). Chalmers University of Technology.
78. Purely functional data structures (http://www.cambridge.org/us/academic/subjects/com
puter-science/algorithmics-complexity-computer-algebra-and-computational-g/purely-
functional-data-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" (h
ttp://www.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-way
s-of-looking-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/books?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" (http://w
ww.codecommit.com/blog/scala/implementing-persistent-vectors-in-scala). Code
Commit.
85. "Which programs are fastest? | Computer Language Benchmarks Game" (https://web.
archive.org/web/20130520162513/http://benchmarksgame.alioth.debian.org/u32/whic
h-programs-are-fastest.php?gcc=on&ghc=on&clean=on&ocaml=on&sbcl=on&fsharp=o
n&racket=on&clojure=on&hipe=on&calc=chart). benchmarksgame.alioth.debian.org.
Archived from the original (http://benchmarksgame.alioth.debian.org/u32/which-progr
ams-are-fastest.php?gcc=on&ghc=on&clean=on&ocaml=on&sbcl=on&fsharp=on&rack
et=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.
semanticscholar.org/CorpusID:34527406).
87. "An In-Depth Look at Clojure Collections" (https://www.infoq.com/articles/in-depth-loo
k-clojure-collections/). InfoQ. Retrieved 2024-04-29.
88. "References and Borrowing - The Rust Programming Language" (https://doc.rust-lang.
org/book/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-lang.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)" (h
ttps://docs.oracle.com/javase/tutorial/essential/concurrency/collections.html).
docs.oracle.com. Retrieved 2024-04-29.

18 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

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 0596555857, 9780596555856. {{cite book}}: Check |isbn= value: invalid
character (help)
93. "Chapter 25. Profiling and optimization" (http://book.realworldhaskell.org/read/profilin
g-and-optimization.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" (http
s://go.dev/wiki/CompilerOptimizations). go.dev. Retrieved 2024-04-29.
96. "Comparing Performance: Loops vs. Iterators - The Rust Programming Language" (http
s://doc.rust-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"
(http://www.ub.utwente.nl/webdocs/ctit/1/00000084.pdf) (PDF). Journal of Functional
Programming. 14 (2): 129–135. doi:10.1017/S0956796803004817 (https://doi.org/10.101
7%2FS0956796803004817). S2CID 32346900 (https://api.semanticscholar.org/CorpusI
D:32346900).; David Mertz. "Functional programming in Python, Part 3" (https://web.ar
chive.org/web/20071016124848/http://www-128.ibm.com/developerworks/linux/librar
y/l-prog3.html). IBM developerWorks. Archived from the original (http://www-128.ibm.co
m/developerworks/linux/library/l-prog3.html) on 2007-10-16. Retrieved
2006-09-17.(Part 1 (https://web.archive.org/web/20071016124848/http://www-128.ib
m.com/developerworks/linux/library/l-prog.html), Part 2 (https://web.archive.org/web/
20071016124848/http://www-128.ibm.com/developerworks/linux/library/l-prog2.html))
98. "Functions — D Programming Language 2.0" (http://www.digitalmars.com/d/2.0/functi
on.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/
codewalk/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://pyt
hon-history.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.p
ython.org/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://blog
s.oracle.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.co
m/javatraining/entry/java_se_8_lambda_quick).
107. Bloch, Joshua (2008). "Item 15: Minimize Mutability". Effective Java (https://archive.org/d
etails/effectivejava00bloc_0) (Second ed.). Addison-Wesley. ISBN 978-0321356680.

19 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

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

aScript/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.activemod
e.org/webroot/Workers/ActiveTraining/Programming/Pro_SpreadsheetFunctionalProgr
amming.pdf) (PDF). Journal of Functional Programming. 17 (1): 131–143.
doi:10.1017/S0956796806006186 (https://doi.org/10.1017%2FS0956796806006186).
ISSN 0956-7968 (https://www.worldcat.org/issn/0956-7968). S2CID 29429059 (https://a
pi.semanticscholar.org/CorpusID:29429059).
114. Peyton Jones, Simon; Burnett, Margaret; Blackwell, Alan (March 2003). "Improving the
world's most popular functional language: user-defined functions in Excel" (https://we
b.archive.org/web/20051016011341/http://research.microsoft.com/~simonpj/Papers/e
xcel/index.htm). Archived from the original (http://research.microsoft.com/~simonpj/P
apers/excel/index.htm) on 2005-10-16.
115. Piro, Christopher (2009). Functional Programming at Facebook (https://web.archive.org/
web/20091017070140/http://cufp.galois.com/2009/abstracts.html#ChristopherPiroEug
eneLetuchy). CUFP 2009. Archived from the original (http://cufp.galois.com/2009/abstr
acts.html#ChristopherPiroEugeneLetuchy) on 2009-10-17. Retrieved 2009-08-29.
116. "Sim-Diasca: a large-scale discrete event concurrent simulation engine in Erlang" (htt
p://research.edf.com/research-and-the-scientific-community/software/sim-diasca-8070
4.html). November 2011.
117. 1 million is so 2011 (https://blog.whatsapp.com/index.php/2012/01/1-million-is-so-201
1/) Archived (https://web.archive.org/web/20140219234031/http://blog.whatsapp.com/
index.php/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"
118. Momtahan, Lee (2009). Scala at EDF Trading: Implementing a Domain-Specific Language
for Derivative Pricing with Scala (https://web.archive.org/web/20091017070140/http://cu
fp.galois.com/2009/abstracts.html#LeeMomtahan). CUFP 2009. Archived from the
original (http://cufp.galois.com/2009/abstracts.html#LeeMomtahan) on 2009-10-17.
Retrieved 2009-08-29.
119. Graham, Paul (2003). "Beating the Averages" (http://www.paulgraham.com/avg.html).
Retrieved 2009-08-29.
120. Sims, Steve (2006). Building a Startup with Standard ML (http://cufp.galois.com/2006/slid
es/SteveSims.pdf) (PDF). CUFP 2006. Retrieved 2009-08-29.
121. Laurikari, Ville (2007). Functional Programming in Communications Security (http://cufp.g
alois.com/2007/abstracts.html#VilleLaurikari). CUFP 2007. Retrieved 2009-08-29.

20 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

122. Lorimer, R. J. (19 January 2009). "Live Production Clojure Application Announced" (htt
p://www.infoq.com/news/2009/01/clojure_production). InfoQ.
123. Bugnion, Pascal (2016). Scala for Data Science (1st ed.). Packt. ISBN 9781785281372.
124. "Why developers like ClojureScript" (https://stackshare.io/clojurescript). StackShare.
Retrieved 2024-04-29.
125. Herrick, Justin (2024-04-29), jah2488/elm-companies (https://github.com/jah2488/elm-c
ompanies), retrieved 2024-04-29
126. "Why developers like PureScript" (https://stackshare.io/purescript). StackShare.
Retrieved 2024-04-29.
127. Team, Editorial (2019-01-08). "ALLEGRO - all you need to know about the best Polish
online marketplace" (https://ecommercegermany.com/blog/allegro-all-you-need-to-kn
ow-about-the-best-polish-online-marketplace). E-commerce Germany News. Retrieved
2024-04-29.
128. "Websites using Phoenix Framework - Wappalyzer" (https://www.wappalyzer.com/tech
nologies/web-frameworks/phoenix-framework/). www.wappalyzer.com. Retrieved
2024-04-29.
129. "Functional Programming: 2019-2020" (https://www.cs.ox.ac.uk/teaching/courses/2019
-2020/fp/). University of Oxford Department of Computer Science. Retrieved 28 April
2020.
130. "Programming I (Haskell)" (https://www.imperial.ac.uk/computing/current-students/co
urses/120_1/). Imperial College London Department of Computing. Retrieved 28 April
2020.
131. "Computer Science BSc - Modules" (https://www.nottingham.ac.uk/ugstudy/course/Co
mputer-Science-BSc#yearsmodules). Retrieved 28 April 2020.
132. Abelson, Hal; Sussman, Gerald Jay (1985). "Preface to the Second Edition" (https://mitpr
ess.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-6.html). Structure and
Interpretation of Computer Programs (http://mitpress.mit.edu/sicp/) (2 ed.). MIT Press.
133. John DeNero (Fall 2019). "Computer Science 61A, Berkeley" (https://cs61a.org/articles/a
bout.html). Department of Electrical Engineering and Computer Sciences, Berkeley.
Retrieved 2020-08-14.
134. Emmanuel Schanzer of Bootstrap (https://twit.tv/shows/triangulation/episodes/196/)
interviewed on the TV show Triangulation on the TWiT.tv network
135. "Why Scheme for Introductory Programming?" (https://home.adelphi.edu/sbloch/class
/pbd/testimonials/). home.adelphi.edu. Retrieved 2024-04-29.
136. Staff, IMACS (2011-06-03). "What Is Scheme & Why Is it Beneficial for Students?" (http
s://www.imacs.org/learn-computer-programming-using-scheme/). IMACS – Making
Better Thinkers for Life. Retrieved 2024-04-29.

Further reading
▪ Abelson, Hal; Sussman, Gerald Jay (1985). Structure and Interpretation of Computer
Programs (http://mitpress.mit.edu/sicp/). MIT Press.
▪ Cousineau, Guy and Michel Mauny. The Functional Approach to Programming.
Cambridge, UK: Cambridge University Press, 1998.
▪ Curry, Haskell Brooks and Feys, Robert and Craig, William. Combinatory Logic. Volume I.
North-Holland Publishing Company, Amsterdam, 1958.
▪ Curry, Haskell B.; Hindley, J. Roger; Seldin, Jonathan P. (1972). Combinatory Logic. Vol. II.
Amsterdam: North Holland. ISBN 978-0-7204-2208-5.

21 of 22 5/9/24, 21:15
Functional programming - Wikipedia https://en.wikipedia.org/wiki/Functional_programming

▪ Dominus, Mark Jason. Higher-Order Perl (http://hop.perl.plover.com/book/pdf/HigherOrder

Perl.pdf). Morgan Kaufmann. 2005.
▪ Felleisen, Matthias; Findler, Robert; Flatt, Matthew; Krishnamurthi, Shriram (2018). How
to Design Programs (http://www.htdp.org). MIT Press.
▪ Graham, Paul. ANSI Common LISP. Englewood Cliffs, New Jersey: Prentice Hall, 1996.
▪ MacLennan, Bruce J. Functional Programming: Practice and Theory. Addison-Wesley,
1990.
▪ Michaelson, Greg (10 April 2013). An Introduction to Functional Programming Through
Lambda Calculus. Courier Corporation. ISBN 978-0-486-28029-5.[1]
▪ O'Sullivan, Brian; Stewart, Don; Goerzen, John (2008). Real World Haskell (http://book.re
alworldhaskell.org/read/). O'Reilly.
▪ Pratt, Terrence W. and Marvin Victor Zelkowitz. Programming Languages: Design and
Implementation. 3rd ed. Englewood Cliffs, New Jersey: Prentice Hall, 1996.
▪ Salus, Peter H. Functional and Logic Programming Languages. Vol. 4 of Handbook of
Programming Languages. Indianapolis, Indiana: Macmillan Technical Publishing, 1998.
▪ Thompson, Simon. Haskell: The Craft of Functional Programming. Harlow, England:
Addison-Wesley Longman Limited, 1996.

External links
▪ Ford, Neal. "Functional thinking" (http://nealford.com/functionalthinking.html).
Retrieved 2021-11-10.
▪ Akhmechet, Slava (2006-06-19). "defmacro – Functional Programming For The Rest of
Us" (http://www.defmacro.org/ramblings/fp.html). Retrieved 2013-02-24. An
introduction
▪ Functional programming in Python (by David Mertz): part 1 (http://gnosis.cx/publish/pro
gramming/charming_python_13.html), part 2 (http://gnosis.cx/publish/programming/c
harming_python_16.html), part 3 (http://gnosis.cx/publish/programming/charming_pyt
hon_19.html)

1. "Greg Michaelson's Homepage" (http://www.macs.hw.ac.uk/~greg/). Mathematical and

Computer Sciences. Riccarton, Edinburgh: Heriot-Watt University. Retrieved 6 November
2022.

Retrieved from "https://en.wikipedia.org/w/index.php?title=Functional_programming&oldid=1222988961"

22 of 22 5/9/24, 21:15