# Functional programming

In computer science, functional programming is a programming paradigm—a style of building the structure and elements of computer programs—that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data. It is a declarative programming paradigm, which means programming is done with expressions. In functional code, the output value of a function depends only on the arguments that are input to the function, so calling a function f twice with the same value for an argument x will produce the same result f(x) each time. Eliminating side effects, i.e. changes in state that do not depend on the function inputs, can make it much easier to understand and predict the behavior of a program, which is one of the key motivations for the development of functional programming.

Functional programming has its roots in lambda calculus, a formal system developed in the 1930s to investigate computability, the Entscheidungsproblem, function definition, function application, and recursion. Many functional programming languages can be viewed as elaborations on the lambda calculus. Another well-known declarative programming paradigm, logic programming, is based on relations.[1]

In contrast, imperative programming changes state with commands in the source language, the most simple example being assignment. Imperative programming does have functions—not in the mathematical sense—but in the sense of subroutines. They can have side effects that may change the value of program state. Functions without return values therefore make sense. Because of this, they lack referential transparency, i.e. the same language expression can result in different values at different times depending on the state of the executing program.[1]

Functional programming languages, especially purely functional ones such as Hope and Rex, have largely been emphasized in academia rather than in commercial software development. However, prominent programming languages which support functional programming such as Common Lisp, Scheme,[2][3][4][5] Clojure,[6][7] Wolfram Language [8] (also known as Mathematica), Racket,[9] Erlang,[10][11][12] OCaml,[13][14] Haskell,[15][16] and F#[17][18] have been used in industrial and commercial applications by a wide variety of organizations. Functional programming is also supported in some domain-specific programming languages like R (statistics),[19] J, K and Q from Kx Systems (financial analysis), XQuery/XSLT (XML),[20][21] and Opal.[22] Widespread domain-specific declarative languages like SQL and Lex/Yacc use some elements of functional programming, especially in eschewing mutable values.[23]

Programming in a functional style can also be accomplished in languages that are not specifically designed for functional programming. For example, the imperative Perl programming language has been the subject of a book describing how to apply functional programming concepts.[24] This is also true of the PHP programming language.[25] C# 3.0 and Java 8 added constructs to facilitate the functional style. The Julia language also offers functional programming abilities. An interesting case is that of Scala[26] – it is frequently written in a functional style, but the presence of side effects and mutable state place it in a grey area between imperative and functional languages.

## History

Lambda calculus provides a theoretical framework for describing functions and their evaluation. Although it is a mathematical abstraction rather than a programming language, it forms the basis of almost all functional programming languages today. An equivalent theoretical formulation, combinatory logic, is commonly perceived as more abstract than lambda calculus and preceded it in invention. Combinatory logic and lambda calculus were both originally developed to achieve a clearer approach to the foundations of mathematics.[27]

An early functional-flavored language was Lisp, developed by John McCarthy while at Massachusetts Institute of Technology (MIT) for the IBM 700/7000 series scientific computers in the late 1950s.[28] Lisp introduced many features now found in functional languages, though Lisp is technically a multi-paradigm language. Scheme and Dylan were later attempts to simplify and improve Lisp.

Information Processing Language (IPL) is sometimes cited as the first computer-based functional programming language.[29] It is an assembly-style language for manipulating lists of symbols. It does have a notion of "generator", which amounts to a function accepting a function as an argument, and, since it is an assembly-level language, code can be used as data, so IPL can be regarded as having higher-order functions. However, it relies heavily on 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.

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".[30] 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 which has come to be associated with functional programming.

In the 1970s, ML was created by Robin Milner at the University of Edinburgh, and David Turner initially developed the language SASL at the University of St. Andrews and later the language Miranda at the University of Kent. Also in Edinburgh in the 1970s, Burstall and Darlington developed the functional language NPL.[31] NPL was based on Kleene Recursion Equations and was first introduced in their work on program transformation.[32] Burstall, MacQueen and Sannella then incorporated the polymorphic type checking from ML to produce the language Hope.[33] ML eventually developed into several dialects, the most common of which are now OCaml and Standard ML. Meanwhile, the development of Scheme (a partly functional dialect of Lisp), as described in the influential Lambda Papers and the 1985 textbook Structure and Interpretation of Computer Programs, brought awareness of the power of functional programming to the wider programming-languages community.

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

The Haskell language began with a consensus in 1987 to form an open standard for functional programming research; implementation releases have been ongoing since 1990.

## Concepts

A number of concepts and paradigms are specific to functional programming, and generally foreign to imperative programming (including object-oriented programming). However, programming languages are often hybrids of several programming paradigms, so programmers using "mostly imperative" languages may have utilized some of these concepts.[34]

### 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 $d/dx$, which returns the derivative of a function $f$.

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. The 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 that describes 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 in which a function is applied to its arguments one at a time, with each application returning a new function that accepts the next argument. This allows one to succinctly express, for example, the successor function as the addition operator partially applied to the natural number one.

### Pure functions

Purely functional functions (or expressions) have no side effects (memory or I/O). This 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 constant with respect to that argument list (sometimes called referential transparency), i.e. if the pure function is again called with the same arguments, the same result will be returned (this can enable caching optimizations such as memoization).
• If there is no data dependency between two pure expressions, then 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 allows functions to be designated "pure".

### Recursion

Iteration (looping) in functional languages is usually accomplished via recursion. Recursive functions invoke themselves, allowing an operation to be performed over and over until the base case is reached. Though some recursion requires maintaining a stack, tail recursion can be recognized and optimized by a compiler into the same code used to implement iteration in imperative languages. The Scheme language standard requires implementations to recognize and optimize tail recursion. Tail recursion optimization can be implemented by transforming the program into continuation passing style during compiling, among other approaches.

Common patterns of recursion can be factored out using higher order functions, with catamorphisms and anamorphisms (or "folds" and "unfolds") being the most obvious examples. Such higher order functions 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.[35]

### 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 will itself fail. For example, the expression:

```print length([2+1, 3*2, 1/0, 5-4])
```

will fail under strict evaluation because of the division by zero in the third element of the list. Under lazy evaluation, the length function will return the value 4 (i.e., the number of items in the list), since evaluating it will 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.[36] 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.[37] 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.[38] Harper 2009 proposes including both strict and lazy evaluation in the same language, using the language's type system to distinguish them.[39]

### Type systems

Especially since the development of Hindley–Milner type inference in the 1970s, functional programming languages have tended to use typed lambda calculus, as opposed to the untyped lambda calculus used in Lisp and its variants (such as Scheme). The use of algebraic datatypes and pattern matching makes manipulation of complex data structures convenient and expressive; the presence of strong compile-time type checking makes programs more reliable, while type inference frees the programmer from the need to manually declare types to the compiler.

Some research-oriented functional languages such as Coq, Agda, Cayenne, and Epigram are based on intuitionistic type theory, which allows types to 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[citation needed]. But dependent types can express arbitrary propositions in predicate 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 C programming language that is written in Coq and formally verified.[40]

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.[41] GADT's are available in the Glasgow Haskell Compiler, in OCaml (since version 4.00) and in Scala (as "case classes"), and have been proposed as additions to other languages including Java and C#.[42]

### 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. [43]

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 `10`, then two consecutive evaluations of the variable `x` will yield `10` and `100` respectively. Clearly, replacing `x = x * 10` with either `10` or `100` gives a program with 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 will 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.

### 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.[44] For example, both D and Fortran 95 explicitly support pure functions.[45]

JavaScript, Lua[46] and Python had first class functions from their inception.[47] Amrit Prem added support to Python for "lambda", "map", "reduce", and "filter" in 1994, as well as closures in Python 2.2,[48] though Python 3 relegated "reduce" to the `functools` standard library module.[49] First-class functions have been introduced into other mainstream languages such as PHP 5.3, Visual Basic 9, C# 3.0, and C++11.[citation needed]

In Java, anonymous classes can sometimes be used to simulate closures;[50] however, anonymous classes are not always proper replacements to closures because they have more limited capabilities.[51] Java 8 supports lambda expressions as a replacement for some anonymous classes.[52] However, the presence of checked exceptions in Java can make functional programming inconvenient, because it can be necessary to catch checked exceptions and then rethrow them—a problem that does not occur in other JVM languages that do not have checked exceptions, such as Scala.[citation needed]

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 patterns are expressible in functional programming terms: for example, the strategy pattern simply dictates use of a higher-order function, and the visitor pattern roughly corresponds to a catamorphism, or fold.

Similarly, the idea of immutable data from functional programming is often included in imperative programming languages,[53] for example the tuple in Python, which is an immutable array.

## Comparison to imperative programming

Functional programming is very different from imperative programming. The 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, which makes it easier to verify, optimize, and parallelize programs, and easier to write automated tools to perform those tasks.[citation needed]

Higher-order functions are rarely used in older imperative programming. A traditional imperative 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.

### 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. 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).[54]

Another way in which functional languages can simulate state is by passing around a data structure that represents the current state as a parameter to function calls. On each function call, a copy of this data structure is created with whatever differences are the result of the function. This is referred to as 'state-passing style'.

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.[55] This is related to the fact that some mutable data structures like arrays have a very straightforward implementation using present hardware (which is a highly evolved Turing machine). 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).[56] 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.[57] 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.[58]

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[38] discusses theoretical issues related to memory leaks from lazy evaluation, and O'Sullivan et al. 2008[59] 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)[citation needed].

### Coding styles

Imperative programs tend to emphasize the series of steps taken by a program in carrying out an action, while functional programs tend to emphasize the composition and arrangement of functions, often without specifying explicit steps. A simple example illustrates this with two solutions to the same programming goal (calculating Fibonacci numbers). The imperative example is in Python.

Version 1 – With Generators

```# Fibonacci numbers, imperative style
# https://docs.python.org/2.7/tutorial/modules.html
def fibonacci(n, first=0, second=1):
for i in range(n):
yield first  # Return current iteration
first, second = second, first + second

print [x for x in fibonacci(10)]
```

Version 2 – Iterative

```def fibonacci(n):
first, second = 0, 1
for i in range(n):
print first  # Print current iteration
first, second = second, first + second #Calculate next values

fibonacci(10)
```

Version 3 – Recursive

```def fibonacci(n, first=0, second=1):
if n == 1:
return [first]
else:
return [first] + fibonacci(n - 1, second, first + second)

print fibonacci(10)
```

A functional version (in Haskell) has a different feel to it[vague]:

```-- Fibonacci numbers, functional style

-- describe an infinite list based on the recurrence relation for Fibonacci numbers
fibRecurrence first second = first : fibRecurrence second (first + second)

-- describe fibonacci list as fibRecurrence with initial values 0 and 1
fibonacci = fibRecurrence 0 1

-- describe action to print the 10th element of the fibonacci list
main = print (fibonacci !! 10)
```

Or, more concisely:

```fibonacci2 = 0:1:zipWith (+) fibonacci2 (tail fibonacci2)
```

The imperative style describes the intermediate steps involved in calculating `fibonacci(N)`, and places those steps inside a loop statement. In contrast, the functional implementation shown here states the mathematical recurrence relation that defines the entire Fibonacci sequence, then selects an element from the sequence (see also recursion). This example relies on Haskell's lazy evaluation to create an "infinite" list of which only as much as needed (the first 10 elements in this case) will actually be computed. That computation happens when the runtime system carries out the action described by "main".

#### Erlang

The same program in Erlang provides a simple example of how functional languages in general do not require their syntax to contain an "if" statement.

```-module(fibonacci).
-export([start/1]).

%% Fibonacci numbers in Erlang
start(N) -> do_fib(0, 1, N).

do_fib(_, B, 1) -> B;
do_fib(A, B, N) -> do_fib(B, A + B, N - 1).
```

This program is contained within a module called "fibonacci" and declares that the start/1 function will be visible from outside the scope of this module.

The function start/1 accepts a single parameter (as denoted by the "/1" syntax) and then calls an internal function called do_fib/3.

In direct contrast to the imperative coding style, Erlang does not need an "if" statement because the Erlang runtime will examine the parameters being passed to a function, and call the first function having a signature that matches the current pattern of parameters. (Erlang syntax does provide an "if" statement, but it is considered syntactic sugar and, compared to its usage in imperative languages, plays only a minor role in application logic design).

In this case, it is unnecessary to test for a parameter value within the body of the function because such a test is implicitly performed by providing a set of function signatures that describe the different patterns of values that could be received by a function.

In the case above, the first version of do_fib/3 will only be called when the third parameter has the precise value of 1. In all other cases, the second version of do_fib/3 will be called.

This example demonstrates that functional programming languages often implement conditional logic implicitly by matching parameter patterns rather than explicitly by means of an "if" statement.

#### Elixir

Elixir is a functional, concurrent, general-purpose programming language that runs on the Erlang virtual machine (BEAM).

The Fibonacci function can be written in Elixir as follows:

```defmodule Fibonacci do
def fib(0), do: 0
def fib(1), do: 1
def fib(n), do: fib(n-1) + fib(n-2)
end
```

#### Lisp

The Fibonacci function can be written in Common Lisp as follows:

```(defun fib (n &optional (a 0) (b 1))
(if (= n 0)
a
(fib (- n 1) b (+ a b))))
```

The program can then be called as

```(fib 10)
```

#### D

D has support for functional programming[clarification needed][citation needed]:

```import std.stdio;
import std.range;

void main()
{
/* 'f' is a range representing the first 10 Fibonacci numbers */
auto f = recurrence!((seq, i) => seq[0] + seq[1])(0, 1)
.take(10);

writeln(f);
}
```

#### R

R (programming language) is an environment for statistical computing and graphics. It is also a functional programming language.

The Fibonacci function can be written in R as a recursive function as follows:

```fib <- function(n) {
if (n <= 2) 1
else fib(n - 1) + fib(n - 2)
}
```

Or it can be written as a singly recursive function:

```fib <- function(n,a=1,b=1) {
if (n == 1) a
else fib(n-1,b,a+b)
}
```

Or it can be written as an iterative function:

```fib <- function(n) {
if (n == 1) 1
else if (n == 2) 1
else {
fib<-c(1,1)
for (i in 3:n) fib<-c(0,fib[1])+fib[2]
fib[2]
}
}
```

The function can then be called as

```fib(10)
```

## Use in industry

Functional programming has long been popular in academia, but with few industrial applications.[60]:page 11 However, recently several prominent functional programming languages have been used in commercial or industrial systems. For example, the Erlang programming language, which was developed by the Swedish company Ericsson in the late 1980s, was originally used to implement fault-tolerant telecommunications systems.[11] It has since become popular for building a range of applications at companies such as T-Mobile, Nortel, Facebook, Électricité de France and WhatsApp.[10][12][61][62][63] The Scheme dialect of Lisp was used as the basis for several applications on early Apple Macintosh computers,[2][3] and has more recently been applied to problems such as training simulation software[4] and telescope control.[5] OCaml, which was introduced in the mid-1990s, has seen commercial use in areas such as financial analysis,[13] driver verification, industrial robot programming, and static analysis of embedded software.[14] Haskell, although initially intended as a research language,[16] has also been applied by a range of companies, in areas such as aerospace systems, hardware design, and web programming.[15][16]

Other functional programming languages that have seen use in industry include Scala,[64] F#,[17][18] (both being functional-OO hybrids with support for both purely functional and imperative programming) Wolfram Language,[8] Lisp,[65] Standard ML,[66][67] and Clojure.[68]

## In education

Functional programming is being used as a method to teach problem solving, algebra and geometric concepts.[69] It has also been used as a tool to teach classical mechanics in Structure and Interpretation of Classical Mechanics.

## References

1. Hudak, Paul (September 1989). "Conception, evolution, and application of functional programming languages" (PDF). ACM Computing Surveys. 21 (3): 359–411. doi:10.1145/72551.72554.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
2. Clinger, Will (1987). "MultiTasking and MacScheme". MacTech. 3 (12). Retrieved 2008-08-28.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
3. Hartheimer, Anne (1987). "Programming a Text Editor in MacScheme+Toolsmith". MacTech. 3 (1). Retrieved 2008-08-28.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
4. Kidd, Eric. Terrorism Response Training in Scheme. CUFP 2007. Retrieved 2009-08-26.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
5. Cleis, Richard. Scheme in Space. CUFP 2006. Retrieved 2009-08-26.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
6. "The useR! 2006 conference schedule includes papers on the commercial use of R". R-project.org. 2006-06-08. Retrieved 2011-06-20.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
7. Chambers, John M. (1998). Programming with Data: A Guide to the S Language. Springer Verlag. pp. 67–70. ISBN 978-0-387-98503-9.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
8. "Wolfram Language Guide: Functional Programming". 2015. Retrieved 2015-08-24.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
9. "State-Based Scripting in Uncharted 2" (PDF). Retrieved 2011-08-08.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
10. "Who uses Erlang for product development?". Frequently asked questions about Erlang. Retrieved 2007-08-05.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
11. Armstrong, Joe (June 2007). A history of Erlang. Third ACM SIGPLAN Conference on History of Programming Languages. San Diego, California. Retrieved 2009-08-29.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
12. Larson, Jim (March 2009). "Erlang for concurrent programming". Communications of the ACM. 52 (3): 48. doi:10.1145/1467247.1467263.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
13. Minsky, Yaron; Weeks, Stephen (July 2008). "Caml Trading — experiences with functional programming on Wall Street". Journal of Functional Programming. Cambridge University Press. 18 (4): 553–564. doi:10.1017/S095679680800676X. Retrieved 2008-08-27.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
14. Leroy, Xavier. Some uses of Caml in Industry (PDF). CUFP 2007. Retrieved 2009-08-26.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
15. "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.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
16. Hudak, Paul; Hughes, J.; Jones, S. P.; Wadler, P. (June 2007). A history of Haskell: being lazy with class. Third ACM SIGPLAN Conference on History of Programming Languages. San Diego, California. doi:10.1145/1238844.1238856. Retrieved 2013-09-26.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
17. Mansell, Howard (2008). Quantitative Finance in F#. CUFP 2008. Retrieved 2009-08-29.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
18. Peake, Alex (2009). The First Substantial Line of Business Application in F#. CUFP 2009. Retrieved 2009-08-29.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
19. Department of Applied Math, University of Colorado. "Functional vs. Procedural Programming Language". Retrieved 2006-08-28.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
20. Dimitre Novatchev. "The Functional Programming Language XSLT — A proof through examples". TopXML. Retrieved May 27, 2006.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
21. David Mertz. "XML Programming Paradigms (part four): Functional Programming approached to XML processing". IBM developerWorks. Retrieved May 27, 2006.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
22. OPtimized Applicative Language
23. Donald D. Chamberlin and Raymond F. Boyce (1974). "SEQUEL: A structured English query language". Proceedings of the 1974 ACM SIGFIDET: 249–264.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
24. Dominus, Mark J. (2005). Higher-Order Perl. Morgan Kaufmann. ISBN 1-55860-701-3.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
25. Holywell, Simon (2014). Functional Programming in PHP. php[architect]. ISBN 9781940111056.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
26. "Effective Scala". Scala Wiki. Retrieved 2012-02-21. Effective Scala.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
27. Haskell Brooks Curry; Robert Feys (1958). Combinatory Logic. North-Holland Publishing Company. Retrieved 10 February 2013.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
28. McCarthy, John (June 1978). "History of Lisp". In ACM SIGPLAN History of Programming Languages Conference: 217–223. doi:10.1145/800025.808387.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
29. 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 which proved theorems from Principia Mathematica automatically. In order to accomplish this, they had to invent a language and a paradigm which, which viewed retrospectively, embeds functional programming.
31. 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)
32. 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)
33. R.M. Burstall, D.B. MacQueen and D.T. Sannella. HOPE: an experimental applicative language. Proc. 1980 LISP Conference, Stanford, 136–143 (1980).
34. Dick Pountain. "Functional Programming Comes of Age". BYTE.com (August 1994). Retrieved August 31, 2006.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
35. Turner, D.A. (2004-07-28). "Total Functional Programming". Journal of Universal Computer Science. 10 (7): 751–768. doi:10.3217/jucs-010-07-0751.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
36. The Implementation of Functional Programming Languages. Simon Peyton Jones, published by Prentice Hall, 1987
37. Hughes, John (1984). "Why Functional Programming Matters".CS1 maint: ref=harv (link)<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
38. John Launchbury (1993). "A Natural Semantics for Lazy Evaluation".<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
39. Robert W. Harper (2009). Practical Foundations for Programming Languages (PDF).<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
40. "The Compcert verified compiler".<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
41. Simon Peyton Jones, Dimitrios Vytiniotis, Stephanie Weirich, and Geoffrey Washburn. "Simple unification-based type inference for GADTs". ICFP 2006. pp. 50–61.CS1 maint: multiple names: authors list (link)<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
42. Andrew Kennedy and Claudio Russo (October 2005). "Generalized Algebraic Data Types and Object-Oriented Programming" (PDF). OOPSLA. San Diego, California.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles> source of citation
43. Huges, John. "Why Functional Programming Matters" (PDF). http://www.cse.chalmers.se/. Chalmers Tekniska H¨ogskola. External link in `|website=` (help)<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
44. Hartel, Pieter; Henk Muller; Hugh Glaser (March 2004). "The Functional C experience" (PDF). The Journal of Functional Programming. 14 (2): 129–135. doi:10.1017/S0956796803004817.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>; David Mertz. "Functional programming in Python, Part 3". IBM developerWorks. Retrieved 2006-09-17.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>(Part 1, Part 2)
45. "Functions — D Programming Language 2.0". Digital Mars. Retrieved 2011-06-20.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
46. http://www.luafaq.org/#T1.2
47. https://brendaneich.com/2008/04/popularity/
48. van Rossum, Guido (2009-04-21). "Origins of Python's "Functional" Features". The History of Python. Retrieved 2012-09-27. External link in `|publisher=` (help)<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
49. "functools — Higher order functions and operations on callable objects". Python Software Foundation. 2011-07-31. Retrieved 2011-07-31.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
50. Skarsaune, Martin (2008). The SICS Java Port Project Automatic Translation of a Large Object Oriented System from Smalltalk to Java.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
51. Gosling, James. "Closures". James Gosling: on the Java Road. Oracle. Retrieved 11 May 2013.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
52. "Java SE 8 Lambda Quick Start".<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
53. Bloch, Joshua. Effective Java (Second ed.). pp. Item 15.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
55. Larry C. Paulson (28 June 1996). ML for the Working Programmer. Cambridge University Press. ISBN 978-0-521-56543-1. Retrieved 10 February 2013.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
56. Daniel Spiewak. "Implementing Persistent Vectors in Scala". Retrieved Apr 17, 2012.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
57. "Which programs are fastest? | Computer Language Benchmarks Game". benchmarksgame.alioth.debian.org. Retrieved 2011-06-20.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
58. Igor Pechtchanski and Vivek Sarkar (2005). "Immutability specification and its applications". Concurrency and Computation: Practice and Experience. 17 (5–6): 639–662. doi:10.1002/cpe.853.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
59. "Chapter 25. Profiling and optimization". Book.realworldhaskell.org. Retrieved 2011-06-20.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
60. Odersky, Martin; Spoon, Lex; Venners, Bill (December 13, 2010). Programming in Scala: A Comprehensive Step-by-step Guide (2nd ed.). Artima Inc. pp. 883/852. ISBN 978-0-9815316-4-9.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
61. Piro, Christopher (2009). Functional Programming at Facebook. CUFP 2009. Retrieved 2009-08-29.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
62. "Sim-Diasca: a large-scale discrete event concurrent simulation engine in Erlang". November 2011.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
63. 1 million is so 2011 // WhatsApp blog, 2012-01-06: "the last important piece of our infrastracture is Erlang"
64. Momtahan, Lee (2009). Scala at EDF Trading: Implementing a Domain-Specific Language for Derivative Pricing with Scala. CUFP 2009. Retrieved 2009-08-29.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
65. Graham, Paul (2003). "Beating the Averages". Retrieved 2009-08-29.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
66. Sims, Steve (2006). Building a Startup with Standard ML (PDF). CUFP 2006. Retrieved 2009-08-29.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
67. Laurikari, Ville (2007). Functional Programming in Communications Security. CUFP 2007. Retrieved 2009-08-29.<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
68. Lorimer, R. J. "Live Production Clojure Application Announced".<templatestyles src="Module:Citation/CS1/styles.css"></templatestyles>
69. Emmanuel Schanzer of Bootstrap interviewed on the TV show Triangulation on the TWiT.tv network